# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'AlertChannelConfig',
    'AlertConditionTerm',
    'AlertMutingRuleCondition',
    'AlertMutingRuleConditionCondition',
    'AlertMutingRuleSchedule',
    'EntityTagsTag',
    'InfraAlertConditionCritical',
    'InfraAlertConditionWarning',
    'MonitorDowntimeEndRepeat',
    'MonitorDowntimeFrequency',
    'MonitorDowntimeFrequencyDaysOfWeek',
    'NotificationChannelProperty',
    'NotificationDestinationAuthBasic',
    'NotificationDestinationAuthCustomHeader',
    'NotificationDestinationAuthToken',
    'NotificationDestinationProperty',
    'NotificationDestinationSecureUrl',
    'NrqlAlertConditionCritical',
    'NrqlAlertConditionCriticalPrediction',
    'NrqlAlertConditionNrql',
    'NrqlAlertConditionOutlierConfiguration',
    'NrqlAlertConditionOutlierConfigurationDbscan',
    'NrqlAlertConditionTerm',
    'NrqlAlertConditionTermPrediction',
    'NrqlAlertConditionWarning',
    'NrqlAlertConditionWarningPrediction',
    'ObfuscationRuleAction',
    'OneDashboardPage',
    'OneDashboardPageWidgetArea',
    'OneDashboardPageWidgetAreaColor',
    'OneDashboardPageWidgetAreaColorSeriesOverride',
    'OneDashboardPageWidgetAreaDataFormat',
    'OneDashboardPageWidgetAreaInitialSorting',
    'OneDashboardPageWidgetAreaNrqlQuery',
    'OneDashboardPageWidgetAreaNullValue',
    'OneDashboardPageWidgetAreaNullValueSeriesOverride',
    'OneDashboardPageWidgetAreaTooltip',
    'OneDashboardPageWidgetAreaUnit',
    'OneDashboardPageWidgetAreaUnitSeriesOverride',
    'OneDashboardPageWidgetBar',
    'OneDashboardPageWidgetBarColor',
    'OneDashboardPageWidgetBarColorSeriesOverride',
    'OneDashboardPageWidgetBarDataFormat',
    'OneDashboardPageWidgetBarInitialSorting',
    'OneDashboardPageWidgetBarNrqlQuery',
    'OneDashboardPageWidgetBarNullValue',
    'OneDashboardPageWidgetBarNullValueSeriesOverride',
    'OneDashboardPageWidgetBarUnit',
    'OneDashboardPageWidgetBarUnitSeriesOverride',
    'OneDashboardPageWidgetBillboard',
    'OneDashboardPageWidgetBillboardBillboardSettings',
    'OneDashboardPageWidgetBillboardBillboardSettingsGridOptions',
    'OneDashboardPageWidgetBillboardBillboardSettingsLink',
    'OneDashboardPageWidgetBillboardBillboardSettingsVisual',
    'OneDashboardPageWidgetBillboardColor',
    'OneDashboardPageWidgetBillboardColorSeriesOverride',
    'OneDashboardPageWidgetBillboardDataFormat',
    'OneDashboardPageWidgetBillboardInitialSorting',
    'OneDashboardPageWidgetBillboardNrqlQuery',
    'OneDashboardPageWidgetBillboardNullValue',
    'OneDashboardPageWidgetBillboardNullValueSeriesOverride',
    'OneDashboardPageWidgetBillboardUnit',
    'OneDashboardPageWidgetBillboardUnitSeriesOverride',
    'OneDashboardPageWidgetBullet',
    'OneDashboardPageWidgetBulletColor',
    'OneDashboardPageWidgetBulletColorSeriesOverride',
    'OneDashboardPageWidgetBulletDataFormat',
    'OneDashboardPageWidgetBulletInitialSorting',
    'OneDashboardPageWidgetBulletNrqlQuery',
    'OneDashboardPageWidgetBulletNullValue',
    'OneDashboardPageWidgetBulletNullValueSeriesOverride',
    'OneDashboardPageWidgetBulletUnit',
    'OneDashboardPageWidgetBulletUnitSeriesOverride',
    'OneDashboardPageWidgetFunnel',
    'OneDashboardPageWidgetFunnelColor',
    'OneDashboardPageWidgetFunnelColorSeriesOverride',
    'OneDashboardPageWidgetFunnelDataFormat',
    'OneDashboardPageWidgetFunnelInitialSorting',
    'OneDashboardPageWidgetFunnelNrqlQuery',
    'OneDashboardPageWidgetFunnelNullValue',
    'OneDashboardPageWidgetFunnelNullValueSeriesOverride',
    'OneDashboardPageWidgetFunnelUnit',
    'OneDashboardPageWidgetFunnelUnitSeriesOverride',
    'OneDashboardPageWidgetHeatmap',
    'OneDashboardPageWidgetHeatmapColor',
    'OneDashboardPageWidgetHeatmapColorSeriesOverride',
    'OneDashboardPageWidgetHeatmapDataFormat',
    'OneDashboardPageWidgetHeatmapInitialSorting',
    'OneDashboardPageWidgetHeatmapNrqlQuery',
    'OneDashboardPageWidgetHeatmapNullValue',
    'OneDashboardPageWidgetHeatmapNullValueSeriesOverride',
    'OneDashboardPageWidgetHeatmapUnit',
    'OneDashboardPageWidgetHeatmapUnitSeriesOverride',
    'OneDashboardPageWidgetHistogram',
    'OneDashboardPageWidgetHistogramColor',
    'OneDashboardPageWidgetHistogramColorSeriesOverride',
    'OneDashboardPageWidgetHistogramDataFormat',
    'OneDashboardPageWidgetHistogramInitialSorting',
    'OneDashboardPageWidgetHistogramNrqlQuery',
    'OneDashboardPageWidgetHistogramNullValue',
    'OneDashboardPageWidgetHistogramNullValueSeriesOverride',
    'OneDashboardPageWidgetHistogramUnit',
    'OneDashboardPageWidgetHistogramUnitSeriesOverride',
    'OneDashboardPageWidgetJson',
    'OneDashboardPageWidgetJsonColor',
    'OneDashboardPageWidgetJsonColorSeriesOverride',
    'OneDashboardPageWidgetJsonDataFormat',
    'OneDashboardPageWidgetJsonInitialSorting',
    'OneDashboardPageWidgetJsonNrqlQuery',
    'OneDashboardPageWidgetJsonNullValue',
    'OneDashboardPageWidgetJsonNullValueSeriesOverride',
    'OneDashboardPageWidgetJsonUnit',
    'OneDashboardPageWidgetJsonUnitSeriesOverride',
    'OneDashboardPageWidgetLine',
    'OneDashboardPageWidgetLineColor',
    'OneDashboardPageWidgetLineColorSeriesOverride',
    'OneDashboardPageWidgetLineDataFormat',
    'OneDashboardPageWidgetLineInitialSorting',
    'OneDashboardPageWidgetLineNrqlQuery',
    'OneDashboardPageWidgetLineNullValue',
    'OneDashboardPageWidgetLineNullValueSeriesOverride',
    'OneDashboardPageWidgetLineThreshold',
    'OneDashboardPageWidgetLineTooltip',
    'OneDashboardPageWidgetLineUnit',
    'OneDashboardPageWidgetLineUnitSeriesOverride',
    'OneDashboardPageWidgetLineYAxisRight',
    'OneDashboardPageWidgetLogTable',
    'OneDashboardPageWidgetLogTableColor',
    'OneDashboardPageWidgetLogTableColorSeriesOverride',
    'OneDashboardPageWidgetLogTableDataFormat',
    'OneDashboardPageWidgetLogTableInitialSorting',
    'OneDashboardPageWidgetLogTableNrqlQuery',
    'OneDashboardPageWidgetLogTableNullValue',
    'OneDashboardPageWidgetLogTableNullValueSeriesOverride',
    'OneDashboardPageWidgetLogTableUnit',
    'OneDashboardPageWidgetLogTableUnitSeriesOverride',
    'OneDashboardPageWidgetMarkdown',
    'OneDashboardPageWidgetMarkdownColor',
    'OneDashboardPageWidgetMarkdownColorSeriesOverride',
    'OneDashboardPageWidgetMarkdownDataFormat',
    'OneDashboardPageWidgetMarkdownInitialSorting',
    'OneDashboardPageWidgetMarkdownNullValue',
    'OneDashboardPageWidgetMarkdownNullValueSeriesOverride',
    'OneDashboardPageWidgetMarkdownUnit',
    'OneDashboardPageWidgetMarkdownUnitSeriesOverride',
    'OneDashboardPageWidgetPy',
    'OneDashboardPageWidgetPyColor',
    'OneDashboardPageWidgetPyColorSeriesOverride',
    'OneDashboardPageWidgetPyDataFormat',
    'OneDashboardPageWidgetPyInitialSorting',
    'OneDashboardPageWidgetPyNrqlQuery',
    'OneDashboardPageWidgetPyNullValue',
    'OneDashboardPageWidgetPyNullValueSeriesOverride',
    'OneDashboardPageWidgetPyUnit',
    'OneDashboardPageWidgetPyUnitSeriesOverride',
    'OneDashboardPageWidgetStackedBar',
    'OneDashboardPageWidgetStackedBarColor',
    'OneDashboardPageWidgetStackedBarColorSeriesOverride',
    'OneDashboardPageWidgetStackedBarDataFormat',
    'OneDashboardPageWidgetStackedBarInitialSorting',
    'OneDashboardPageWidgetStackedBarNrqlQuery',
    'OneDashboardPageWidgetStackedBarNullValue',
    'OneDashboardPageWidgetStackedBarNullValueSeriesOverride',
    'OneDashboardPageWidgetStackedBarTooltip',
    'OneDashboardPageWidgetStackedBarUnit',
    'OneDashboardPageWidgetStackedBarUnitSeriesOverride',
    'OneDashboardPageWidgetTable',
    'OneDashboardPageWidgetTableColor',
    'OneDashboardPageWidgetTableColorSeriesOverride',
    'OneDashboardPageWidgetTableDataFormat',
    'OneDashboardPageWidgetTableInitialSorting',
    'OneDashboardPageWidgetTableNrqlQuery',
    'OneDashboardPageWidgetTableNullValue',
    'OneDashboardPageWidgetTableNullValueSeriesOverride',
    'OneDashboardPageWidgetTableThreshold',
    'OneDashboardPageWidgetTableUnit',
    'OneDashboardPageWidgetTableUnitSeriesOverride',
    'OneDashboardRawPage',
    'OneDashboardRawPageWidget',
    'OneDashboardVariable',
    'OneDashboardVariableItem',
    'OneDashboardVariableNrqlQuery',
    'OneDashboardVariableOption',
    'ServiceLevelEvents',
    'ServiceLevelEventsBadEvents',
    'ServiceLevelEventsBadEventsSelect',
    'ServiceLevelEventsGoodEvents',
    'ServiceLevelEventsGoodEventsSelect',
    'ServiceLevelEventsValidEvents',
    'ServiceLevelEventsValidEventsSelect',
    'ServiceLevelObjective',
    'ServiceLevelObjectiveTimeWindow',
    'ServiceLevelObjectiveTimeWindowRolling',
    'WorkflowDestination',
    'WorkflowEnrichments',
    'WorkflowEnrichmentsNrql',
    'WorkflowEnrichmentsNrqlConfiguration',
    'WorkflowIssuesFilter',
    'WorkflowIssuesFilterPredicate',
    'GetAlertChannelConfigResult',
    'GetEntityTagResult',
    'GetNotificationDestinationPropertyResult',
    'GetNotificationDestinationSecureUrlResult',
    'GetTestGrokPatternTestGrokResult',
    'GetTestGrokPatternTestGrokAttributeResult',
]

@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[_builtins.str] = None,
                 auth_password: Optional[_builtins.str] = None,
                 auth_type: Optional[_builtins.str] = None,
                 auth_username: Optional[_builtins.str] = None,
                 base_url: Optional[_builtins.str] = None,
                 channel: Optional[_builtins.str] = None,
                 headers: Optional[Mapping[str, _builtins.str]] = None,
                 headers_string: Optional[_builtins.str] = None,
                 include_json_attachment: Optional[_builtins.str] = None,
                 key: Optional[_builtins.str] = None,
                 payload: Optional[Mapping[str, _builtins.str]] = None,
                 payload_string: Optional[_builtins.str] = None,
                 payload_type: Optional[_builtins.str] = None,
                 recipients: Optional[_builtins.str] = None,
                 region: Optional[_builtins.str] = None,
                 route_key: Optional[_builtins.str] = None,
                 service_key: Optional[_builtins.str] = None,
                 tags: Optional[_builtins.str] = None,
                 teams: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None,
                 user_id: Optional[_builtins.str] = None):
        """
        :param _builtins.str api_key: The API key for integrating with OpsGenie.
        :param _builtins.str auth_password: Specifies an authentication password for use with a channel. Supported by the webhook channel type.
        :param _builtins.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 _builtins.str auth_username: Specifies an authentication username for use with a channel. Supported by the webhook channel type.
        :param _builtins.str base_url: The base URL of the webhook destination.
        :param _builtins.str channel: The Slack channel to send notifications to.
        :param Mapping[str, _builtins.str] headers: A map of key/value pairs that represents extra HTTP headers to be sent along with the webhook payload.
        :param _builtins.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 _builtins.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.
        :param _builtins.str key: The key for integrating with VictorOps.
        :param Mapping[str, _builtins.str] payload: A map of key/value pairs that represents the webhook payload. Must provide payload_type if setting this argument.
        :param _builtins.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 _builtins.str payload_type: Can either be application/json or application/x-www-form-urlencoded. The payload_type argument is required if payload is set.
        :param _builtins.str recipients: A set of recipients for targeting notifications. Multiple values are comma separated.
        :param _builtins.str region: The data center region to store your data. Valid values are US and EU. Default is US.
        :param _builtins.str route_key: The route key for integrating with VictorOps.
        :param _builtins.str service_key: Specifies the service key for integrating with Pagerduty.
        :param _builtins.str tags: A set of tags for targeting notifications. Multiple values are comma separated.
        :param _builtins.str teams: A set of teams for targeting notifications. Multiple values are comma separated.
        :param _builtins.str url: Your organization's Slack URL.
        :param _builtins.str user_id: The user ID for use with the user channel type.
        """
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="authType")
    def auth_type(self) -> Optional[_builtins.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")

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

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

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

    @_builtins.property
    @pulumi.getter
    def headers(self) -> Optional[Mapping[str, _builtins.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")

    @_builtins.property
    @pulumi.getter(name="headersString")
    def headers_string(self) -> Optional[_builtins.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")

    @_builtins.property
    @pulumi.getter(name="includeJsonAttachment")
    def include_json_attachment(self) -> Optional[_builtins.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.
        """
        return pulumi.get(self, "include_json_attachment")

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

    @_builtins.property
    @pulumi.getter
    def payload(self) -> Optional[Mapping[str, _builtins.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")

    @_builtins.property
    @pulumi.getter(name="payloadString")
    def payload_string(self) -> Optional[_builtins.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")

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

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        Your organization's Slack URL.
        """
        return pulumi.get(self, "url")

    @_builtins.property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[_builtins.str]:
        """
        The user ID for use with the user channel type.
        """
        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: _builtins.int,
                 threshold: _builtins.float,
                 time_function: _builtins.str,
                 operator: Optional[_builtins.str] = None,
                 priority: Optional[_builtins.str] = None):
        """
        :param _builtins.int duration: In minutes, must be in the range of 5 to 120, inclusive.
        :param _builtins.float threshold: Must be 0 or greater.
        :param _builtins.str time_function: One of (all, any).
        :param _builtins.str operator: One of (above, below, equal). Defaults to equal.
        :param _builtins.str priority: One of (critical, warning). Defaults to critical.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def duration(self) -> _builtins.int:
        """
        In minutes, must be in the range of 5 to 120, inclusive.
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> _builtins.float:
        """
        Must be 0 or greater.
        """
        return pulumi.get(self, "threshold")

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

    @_builtins.property
    @pulumi.getter
    def operator(self) -> Optional[_builtins.str]:
        """
        One of (above, below, equal). Defaults to equal.
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.str]:
        """
        One of (critical, warning). Defaults to critical.
        """
        return pulumi.get(self, "priority")


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

    @_builtins.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")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> _builtins.str:
        """
        The operator used to combine all the MutingRuleConditions within the group. Valid values are `AND`, `OR`.
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class AlertMutingRuleConditionCondition(dict):
    def __init__(__self__, *,
                 attribute: _builtins.str,
                 operator: _builtins.str,
                 values: Sequence[_builtins.str]):
        """
        :param _builtins.str attribute: The attribute on an incident.
        :param _builtins.str operator: The operator used to compare the attribute's value with the supplied value(s).
        :param Sequence[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def attribute(self) -> _builtins.str:
        """
        The attribute on an incident.
        """
        return pulumi.get(self, "attribute")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> _builtins.str:
        """
        The operator used to compare the attribute's value with the supplied value(s).
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def values(self) -> Sequence[_builtins.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: _builtins.str,
                 end_repeat: Optional[_builtins.str] = None,
                 end_time: Optional[_builtins.str] = None,
                 repeat: Optional[_builtins.str] = None,
                 repeat_count: Optional[_builtins.int] = None,
                 start_time: Optional[_builtins.str] = None,
                 weekly_repeat_days: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str time_zone: The time zone that applies to the MutingRule schedule.
        :param _builtins.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 _builtins.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'
               * `timeZone` (Required) The time zone that applies to the muting rule schedule. Example: 'America/Los_Angeles'. See https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
        :param _builtins.str repeat: The frequency the muting rule schedule repeats. If it does not repeat, omit this field. Options are DAILY, WEEKLY, MONTHLY
        :param _builtins.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 _builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> _builtins.str:
        """
        The time zone that applies to the MutingRule schedule.
        """
        return pulumi.get(self, "time_zone")

    @_builtins.property
    @pulumi.getter(name="endRepeat")
    def end_repeat(self) -> Optional[_builtins.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")

    @_builtins.property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[_builtins.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'
        * `timeZone` (Required) The time zone that applies to the muting rule schedule. Example: 'America/Los_Angeles'. See https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
        """
        return pulumi.get(self, "end_time")

    @_builtins.property
    @pulumi.getter
    def repeat(self) -> Optional[_builtins.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")

    @_builtins.property
    @pulumi.getter(name="repeatCount")
    def repeat_count(self) -> Optional[_builtins.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")

    @_builtins.property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[_builtins.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")

    @_builtins.property
    @pulumi.getter(name="weeklyRepeatDays")
    def weekly_repeat_days(self) -> Optional[Sequence[_builtins.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: _builtins.str,
                 values: Sequence[_builtins.str]):
        """
        :param _builtins.str key: The key of the tag.
               
               > **NOTE:** One should not use reserved (immutable) keys with this resource. It is recommended to choose unique and descriptive keys which do not conflict with existing reserved keys.
        :param Sequence[_builtins.str] values: The tag values.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @_builtins.property
    @pulumi.getter
    def key(self) -> _builtins.str:
        """
        The key of the tag.

        > **NOTE:** One should not use reserved (immutable) keys with this resource. It is recommended to choose unique and descriptive keys which do not conflict with existing reserved keys.
        """
        return pulumi.get(self, "key")

    @_builtins.property
    @pulumi.getter
    def values(self) -> Sequence[_builtins.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: _builtins.int,
                 time_function: Optional[_builtins.str] = None,
                 value: Optional[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[_builtins.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: _builtins.int,
                 time_function: Optional[_builtins.str] = None,
                 value: Optional[_builtins.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)

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

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

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


@pulumi.output_type
class MonitorDowntimeEndRepeat(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onDate":
            suggest = "on_date"
        elif key == "onRepeat":
            suggest = "on_repeat"

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

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

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

    def __init__(__self__, *,
                 on_date: Optional[_builtins.str] = None,
                 on_repeat: Optional[_builtins.int] = None):
        """
        :param _builtins.str on_date: A date, on which the Monitor Downtime's repeat cycle is expected to end.
        :param _builtins.int on_repeat: Number of repetitions after which the Monitor Downtime's repeat cycle is expected to end.
        """
        if on_date is not None:
            pulumi.set(__self__, "on_date", on_date)
        if on_repeat is not None:
            pulumi.set(__self__, "on_repeat", on_repeat)

    @_builtins.property
    @pulumi.getter(name="onDate")
    def on_date(self) -> Optional[_builtins.str]:
        """
        A date, on which the Monitor Downtime's repeat cycle is expected to end.
        """
        return pulumi.get(self, "on_date")

    @_builtins.property
    @pulumi.getter(name="onRepeat")
    def on_repeat(self) -> Optional[_builtins.int]:
        """
        Number of repetitions after which the Monitor Downtime's repeat cycle is expected to end.
        """
        return pulumi.get(self, "on_repeat")


@pulumi.output_type
class MonitorDowntimeFrequency(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "daysOfMonths":
            suggest = "days_of_months"
        elif key == "daysOfWeek":
            suggest = "days_of_week"

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

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

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

    def __init__(__self__, *,
                 days_of_months: Optional[Sequence[_builtins.int]] = None,
                 days_of_week: Optional['outputs.MonitorDowntimeFrequencyDaysOfWeek'] = None):
        """
        :param Sequence[_builtins.int] days_of_months: A numerical list of days of a month on which the Monitor Downtime is scheduled to run.
        :param 'MonitorDowntimeFrequencyDaysOfWeekArgs' days_of_week: A list of days of the week on which the Monitor Downtime is scheduled to run.
        """
        if days_of_months is not None:
            pulumi.set(__self__, "days_of_months", days_of_months)
        if days_of_week is not None:
            pulumi.set(__self__, "days_of_week", days_of_week)

    @_builtins.property
    @pulumi.getter(name="daysOfMonths")
    def days_of_months(self) -> Optional[Sequence[_builtins.int]]:
        """
        A numerical list of days of a month on which the Monitor Downtime is scheduled to run.
        """
        return pulumi.get(self, "days_of_months")

    @_builtins.property
    @pulumi.getter(name="daysOfWeek")
    def days_of_week(self) -> Optional['outputs.MonitorDowntimeFrequencyDaysOfWeek']:
        """
        A list of days of the week on which the Monitor Downtime is scheduled to run.
        """
        return pulumi.get(self, "days_of_week")


@pulumi.output_type
class MonitorDowntimeFrequencyDaysOfWeek(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ordinalDayOfMonth":
            suggest = "ordinal_day_of_month"
        elif key == "weekDay":
            suggest = "week_day"

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

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

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

    def __init__(__self__, *,
                 ordinal_day_of_month: _builtins.str,
                 week_day: _builtins.str):
        """
        :param _builtins.str ordinal_day_of_month: An occurrence of the day selected within the month.
        :param _builtins.str week_day: The day of the week on which the Monitor Downtime would run.
        """
        pulumi.set(__self__, "ordinal_day_of_month", ordinal_day_of_month)
        pulumi.set(__self__, "week_day", week_day)

    @_builtins.property
    @pulumi.getter(name="ordinalDayOfMonth")
    def ordinal_day_of_month(self) -> _builtins.str:
        """
        An occurrence of the day selected within the month.
        """
        return pulumi.get(self, "ordinal_day_of_month")

    @_builtins.property
    @pulumi.getter(name="weekDay")
    def week_day(self) -> _builtins.str:
        """
        The day of the week on which the Monitor Downtime would run.
        """
        return pulumi.get(self, "week_day")


@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: _builtins.str,
                 value: _builtins.str,
                 display_value: Optional[_builtins.str] = None,
                 label: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: Notification property key.
        :param _builtins.str value: Notification property value.
        :param _builtins.str display_value: Notification property display key.
        :param _builtins.str label: 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)

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

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

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

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


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

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

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


@pulumi.output_type
class NotificationDestinationAuthCustomHeader(dict):
    def __init__(__self__, *,
                 key: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str key: The notification property key.
        :param _builtins.str value: The notification property value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


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

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

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> Optional[_builtins.str]:
        """
        The prefix of the URL.
        """
        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: _builtins.str,
                 value: _builtins.str,
                 display_value: Optional[_builtins.str] = None,
                 label: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: Notification property key.
        :param _builtins.str value: Notification property value.
        :param _builtins.str display_value: Notification property display key.
        :param _builtins.str label: 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)

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

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

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

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


@pulumi.output_type
class NotificationDestinationSecureUrl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secureSuffix":
            suggest = "secure_suffix"

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

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

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

    def __init__(__self__, *,
                 prefix: _builtins.str,
                 secure_suffix: _builtins.str):
        """
        :param _builtins.str prefix: The prefix of the URL.
        :param _builtins.str secure_suffix: The suffix of the URL, which contains sensitive data.
        """
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "secure_suffix", secure_suffix)

    @_builtins.property
    @pulumi.getter
    def prefix(self) -> _builtins.str:
        """
        The prefix of the URL.
        """
        return pulumi.get(self, "prefix")

    @_builtins.property
    @pulumi.getter(name="secureSuffix")
    def secure_suffix(self) -> _builtins.str:
        """
        The suffix of the URL, which contains sensitive data.
        """
        return pulumi.get(self, "secure_suffix")


@pulumi.output_type
class NrqlAlertConditionCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableHealthStatusReporting":
            suggest = "disable_health_status_reporting"
        elif 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: _builtins.float,
                 disable_health_status_reporting: Optional[_builtins.bool] = None,
                 duration: Optional[_builtins.int] = None,
                 operator: Optional[_builtins.str] = None,
                 prediction: Optional['outputs.NrqlAlertConditionCriticalPrediction'] = None,
                 threshold_duration: Optional[_builtins.int] = None,
                 threshold_occurrences: Optional[_builtins.str] = None,
                 time_function: Optional[_builtins.str] = None):
        """
        :param _builtins.float threshold: For baseline conditions must be in range [1, 1000].
        :param _builtins.bool disable_health_status_reporting: Violations will not change system health status for this term.
        :param _builtins.int duration: In minutes, must be in the range of 1 to 120 (inclusive).
        :param _builtins.str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        :param 'NrqlAlertConditionCriticalPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        :param _builtins.int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        :param _builtins.str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        :param _builtins.str time_function: Valid values are: 'all' or 'any'
        """
        pulumi.set(__self__, "threshold", threshold)
        if disable_health_status_reporting is not None:
            pulumi.set(__self__, "disable_health_status_reporting", disable_health_status_reporting)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if prediction is not None:
            pulumi.set(__self__, "prediction", prediction)
        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)

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> _builtins.float:
        """
        For baseline conditions must be in range [1, 1000].
        """
        return pulumi.get(self, "threshold")

    @_builtins.property
    @pulumi.getter(name="disableHealthStatusReporting")
    def disable_health_status_reporting(self) -> Optional[_builtins.bool]:
        """
        Violations will not change system health status for this term.
        """
        return pulumi.get(self, "disable_health_status_reporting")

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""use `threshold_duration` attribute instead""")
    def duration(self) -> Optional[_builtins.int]:
        """
        In minutes, must be in the range of 1 to 120 (inclusive).
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> Optional[_builtins.str]:
        """
        One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def prediction(self) -> Optional['outputs.NrqlAlertConditionCriticalPrediction']:
        """
        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        """
        return pulumi.get(self, "prediction")

    @_builtins.property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[_builtins.int]:
        """
        The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        """
        return pulumi.get(self, "threshold_duration")

    @_builtins.property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[_builtins.str]:
        """
        The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        """
        return pulumi.get(self, "threshold_occurrences")

    @_builtins.property
    @pulumi.getter(name="timeFunction")
    @_utilities.deprecated("""use `threshold_occurrences` attribute instead""")
    def time_function(self) -> Optional[_builtins.str]:
        """
        Valid values are: 'all' or 'any'
        """
        return pulumi.get(self, "time_function")


@pulumi.output_type
class NrqlAlertConditionCriticalPrediction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictBy":
            suggest = "predict_by"
        elif key == "preferPredictionViolation":
            suggest = "prefer_prediction_violation"

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

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

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

    def __init__(__self__, *,
                 predict_by: Optional[_builtins.int] = None,
                 prefer_prediction_violation: Optional[_builtins.bool] = None):
        """
        :param _builtins.int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        :param _builtins.bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        if predict_by is not None:
            pulumi.set(__self__, "predict_by", predict_by)
        if prefer_prediction_violation is not None:
            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)

    @_builtins.property
    @pulumi.getter(name="predictBy")
    def predict_by(self) -> Optional[_builtins.int]:
        """
        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        """
        return pulumi.get(self, "predict_by")

    @_builtins.property
    @pulumi.getter(name="preferPredictionViolation")
    def prefer_prediction_violation(self) -> Optional[_builtins.bool]:
        """
        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        return pulumi.get(self, "prefer_prediction_violation")


@pulumi.output_type
class NrqlAlertConditionNrql(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataAccountId":
            suggest = "data_account_id"
        elif 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: _builtins.str,
                 data_account_id: Optional[_builtins.str] = None,
                 evaluation_offset: Optional[_builtins.int] = None,
                 since_value: Optional[_builtins.str] = None):
        """
        :param _builtins.str data_account_id: The New Relic account ID to use as the basis for the NRQL alert condition's `query`; will default to `account_id` if unspecified.
        :param _builtins.int evaluation_offset: NRQL queries are evaluated in one-minute time windows. The start time depends on the value you provide in the NRQL condition's `evaluation_offset`.
        :param _builtins.str since_value: NRQL queries are evaluated in one-minute time windows. The start time depends on the value you provide in the NRQL condition's `since_value`.
        """
        pulumi.set(__self__, "query", query)
        if data_account_id is not None:
            pulumi.set(__self__, "data_account_id", data_account_id)
        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)

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

    @_builtins.property
    @pulumi.getter(name="dataAccountId")
    def data_account_id(self) -> Optional[_builtins.str]:
        """
        The New Relic account ID to use as the basis for the NRQL alert condition's `query`; will default to `account_id` if unspecified.
        """
        return pulumi.get(self, "data_account_id")

    @_builtins.property
    @pulumi.getter(name="evaluationOffset")
    @_utilities.deprecated("""use `aggregation_method` attribute instead""")
    def evaluation_offset(self) -> Optional[_builtins.int]:
        """
        NRQL queries are evaluated in one-minute time windows. The start time depends on the value you provide in the NRQL condition's `evaluation_offset`.
        """
        return pulumi.get(self, "evaluation_offset")

    @_builtins.property
    @pulumi.getter(name="sinceValue")
    @_utilities.deprecated("""use `aggregation_method` attribute instead""")
    def since_value(self) -> Optional[_builtins.str]:
        """
        NRQL queries are evaluated in one-minute time windows. The start time depends on the value you provide in the NRQL condition's `since_value`.
        """
        return pulumi.get(self, "since_value")


@pulumi.output_type
class NrqlAlertConditionOutlierConfiguration(dict):
    def __init__(__self__, *,
                 dbscan: 'outputs.NrqlAlertConditionOutlierConfigurationDbscan'):
        """
        :param 'NrqlAlertConditionOutlierConfigurationDbscanArgs' dbscan: BETA PREVIEW: the `dbscan` field is in limited release and only enabled for preview on a per-account basis. - Container for DBSCAN settings used to cluster data points and classify noise as outliers. Requires `epsilon` and `minimum_points`; optional `evaluation_group_facet` partitions data before analysis.
        """
        pulumi.set(__self__, "dbscan", dbscan)

    @_builtins.property
    @pulumi.getter
    def dbscan(self) -> 'outputs.NrqlAlertConditionOutlierConfigurationDbscan':
        """
        BETA PREVIEW: the `dbscan` field is in limited release and only enabled for preview on a per-account basis. - Container for DBSCAN settings used to cluster data points and classify noise as outliers. Requires `epsilon` and `minimum_points`; optional `evaluation_group_facet` partitions data before analysis.
        """
        return pulumi.get(self, "dbscan")


@pulumi.output_type
class NrqlAlertConditionOutlierConfigurationDbscan(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minimumPoints":
            suggest = "minimum_points"
        elif key == "evaluationGroupFacet":
            suggest = "evaluation_group_facet"

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

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

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

    def __init__(__self__, *,
                 epsilon: _builtins.float,
                 minimum_points: _builtins.int,
                 evaluation_group_facet: Optional[_builtins.str] = None):
        """
        :param _builtins.float epsilon: BETA PREVIEW: the `epsilon` field is in limited release and only enabled for preview on a per-account basis. - Radius (distance threshold) for DBSCAN in the units of the query result. Smaller values tighten clusters; larger values broaden them. Must be > 0.
        :param _builtins.int minimum_points: BETA PREVIEW: the `minimum_points` field is in limited release and only enabled for preview on a per-account basis. - Minimum number of neighboring points needed to form a cluster. Must be >= 1.
        :param _builtins.str evaluation_group_facet: BETA PREVIEW: the `evaluation_group_facet` field is in limited release and only enabled for preview on a per-account basis. - Optional NRQL facet attribute used to segment data into groups (e.g. `host`, `region`) before running outlier detection. Omit to evaluate all results together.
        """
        pulumi.set(__self__, "epsilon", epsilon)
        pulumi.set(__self__, "minimum_points", minimum_points)
        if evaluation_group_facet is not None:
            pulumi.set(__self__, "evaluation_group_facet", evaluation_group_facet)

    @_builtins.property
    @pulumi.getter
    def epsilon(self) -> _builtins.float:
        """
        BETA PREVIEW: the `epsilon` field is in limited release and only enabled for preview on a per-account basis. - Radius (distance threshold) for DBSCAN in the units of the query result. Smaller values tighten clusters; larger values broaden them. Must be > 0.
        """
        return pulumi.get(self, "epsilon")

    @_builtins.property
    @pulumi.getter(name="minimumPoints")
    def minimum_points(self) -> _builtins.int:
        """
        BETA PREVIEW: the `minimum_points` field is in limited release and only enabled for preview on a per-account basis. - Minimum number of neighboring points needed to form a cluster. Must be >= 1.
        """
        return pulumi.get(self, "minimum_points")

    @_builtins.property
    @pulumi.getter(name="evaluationGroupFacet")
    def evaluation_group_facet(self) -> Optional[_builtins.str]:
        """
        BETA PREVIEW: the `evaluation_group_facet` field is in limited release and only enabled for preview on a per-account basis. - Optional NRQL facet attribute used to segment data into groups (e.g. `host`, `region`) before running outlier detection. Omit to evaluate all results together.
        """
        return pulumi.get(self, "evaluation_group_facet")


@pulumi.output_type
class NrqlAlertConditionTerm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableHealthStatusReporting":
            suggest = "disable_health_status_reporting"
        elif 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: _builtins.float,
                 disable_health_status_reporting: Optional[_builtins.bool] = None,
                 duration: Optional[_builtins.int] = None,
                 operator: Optional[_builtins.str] = None,
                 prediction: Optional['outputs.NrqlAlertConditionTermPrediction'] = None,
                 priority: Optional[_builtins.str] = None,
                 threshold_duration: Optional[_builtins.int] = None,
                 threshold_occurrences: Optional[_builtins.str] = None,
                 time_function: Optional[_builtins.str] = None):
        """
        :param _builtins.float threshold: For baseline conditions must be in range [1, 1000].
        :param _builtins.bool disable_health_status_reporting: Violations will not change system health status for this term.
        :param _builtins.int duration: In minutes, must be in the range of 1 to 120 (inclusive).
        :param _builtins.str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        :param 'NrqlAlertConditionTermPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        :param _builtins.str priority: One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
        :param _builtins.int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        :param _builtins.str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        :param _builtins.str time_function: Valid values are: 'all' or 'any'
        """
        pulumi.set(__self__, "threshold", threshold)
        if disable_health_status_reporting is not None:
            pulumi.set(__self__, "disable_health_status_reporting", disable_health_status_reporting)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if prediction is not None:
            pulumi.set(__self__, "prediction", prediction)
        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)

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> _builtins.float:
        """
        For baseline conditions must be in range [1, 1000].
        """
        return pulumi.get(self, "threshold")

    @_builtins.property
    @pulumi.getter(name="disableHealthStatusReporting")
    def disable_health_status_reporting(self) -> Optional[_builtins.bool]:
        """
        Violations will not change system health status for this term.
        """
        return pulumi.get(self, "disable_health_status_reporting")

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""use `threshold_duration` attribute instead""")
    def duration(self) -> Optional[_builtins.int]:
        """
        In minutes, must be in the range of 1 to 120 (inclusive).
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> Optional[_builtins.str]:
        """
        One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def prediction(self) -> Optional['outputs.NrqlAlertConditionTermPrediction']:
        """
        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        """
        return pulumi.get(self, "prediction")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.str]:
        """
        One of (critical, warning). Defaults to 'critical'. At least one condition term must have priority set to 'critical'.
        """
        return pulumi.get(self, "priority")

    @_builtins.property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[_builtins.int]:
        """
        The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        """
        return pulumi.get(self, "threshold_duration")

    @_builtins.property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[_builtins.str]:
        """
        The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        """
        return pulumi.get(self, "threshold_occurrences")

    @_builtins.property
    @pulumi.getter(name="timeFunction")
    @_utilities.deprecated("""use `threshold_occurrences` attribute instead""")
    def time_function(self) -> Optional[_builtins.str]:
        """
        Valid values are: 'all' or 'any'
        """
        return pulumi.get(self, "time_function")


@pulumi.output_type
class NrqlAlertConditionTermPrediction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictBy":
            suggest = "predict_by"
        elif key == "preferPredictionViolation":
            suggest = "prefer_prediction_violation"

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

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

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

    def __init__(__self__, *,
                 predict_by: Optional[_builtins.int] = None,
                 prefer_prediction_violation: Optional[_builtins.bool] = None):
        """
        :param _builtins.int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        :param _builtins.bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        if predict_by is not None:
            pulumi.set(__self__, "predict_by", predict_by)
        if prefer_prediction_violation is not None:
            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)

    @_builtins.property
    @pulumi.getter(name="predictBy")
    def predict_by(self) -> Optional[_builtins.int]:
        """
        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        """
        return pulumi.get(self, "predict_by")

    @_builtins.property
    @pulumi.getter(name="preferPredictionViolation")
    def prefer_prediction_violation(self) -> Optional[_builtins.bool]:
        """
        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        return pulumi.get(self, "prefer_prediction_violation")


@pulumi.output_type
class NrqlAlertConditionWarning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableHealthStatusReporting":
            suggest = "disable_health_status_reporting"
        elif 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: _builtins.float,
                 disable_health_status_reporting: Optional[_builtins.bool] = None,
                 duration: Optional[_builtins.int] = None,
                 operator: Optional[_builtins.str] = None,
                 prediction: Optional['outputs.NrqlAlertConditionWarningPrediction'] = None,
                 threshold_duration: Optional[_builtins.int] = None,
                 threshold_occurrences: Optional[_builtins.str] = None,
                 time_function: Optional[_builtins.str] = None):
        """
        :param _builtins.float threshold: For baseline conditions must be in range [1, 1000].
        :param _builtins.bool disable_health_status_reporting: Violations will not change system health status for this term.
        :param _builtins.int duration: In minutes, must be in the range of 1 to 120 (inclusive).
        :param _builtins.str operator: One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        :param 'NrqlAlertConditionWarningPredictionArgs' prediction: BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        :param _builtins.int threshold_duration: The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        :param _builtins.str threshold_occurrences: The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        :param _builtins.str time_function: Valid values are: 'all' or 'any'
        """
        pulumi.set(__self__, "threshold", threshold)
        if disable_health_status_reporting is not None:
            pulumi.set(__self__, "disable_health_status_reporting", disable_health_status_reporting)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if prediction is not None:
            pulumi.set(__self__, "prediction", prediction)
        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)

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> _builtins.float:
        """
        For baseline conditions must be in range [1, 1000].
        """
        return pulumi.get(self, "threshold")

    @_builtins.property
    @pulumi.getter(name="disableHealthStatusReporting")
    def disable_health_status_reporting(self) -> Optional[_builtins.bool]:
        """
        Violations will not change system health status for this term.
        """
        return pulumi.get(self, "disable_health_status_reporting")

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""use `threshold_duration` attribute instead""")
    def duration(self) -> Optional[_builtins.int]:
        """
        In minutes, must be in the range of 1 to 120 (inclusive).
        """
        return pulumi.get(self, "duration")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> Optional[_builtins.str]:
        """
        One of (above, above_or_equals, below, below_or_equals, equals, not_equals). Defaults to 'equals'.
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def prediction(self) -> Optional['outputs.NrqlAlertConditionWarningPrediction']:
        """
        BETA PREVIEW: the `prediction` field is in limited release and only enabled for preview on a per-account basis. - Use `prediction` to open alerts when your static threshold is predicted to be reached in the future. The `prediction` field is only available for static conditions.
        """
        return pulumi.get(self, "prediction")

    @_builtins.property
    @pulumi.getter(name="thresholdDuration")
    def threshold_duration(self) -> Optional[_builtins.int]:
        """
        The duration, in seconds, that the threshold must violate in order to create an incident. Value must be a multiple of the 'aggregation_window' (which has a default of 60 seconds). Value must be within 120-86400 seconds for baseline conditions, and within 60-86400 seconds for static conditions
        """
        return pulumi.get(self, "threshold_duration")

    @_builtins.property
    @pulumi.getter(name="thresholdOccurrences")
    def threshold_occurrences(self) -> Optional[_builtins.str]:
        """
        The criteria for how many data points must be in violation for the specified threshold duration. Valid values are: 'ALL' or 'AT_LEAST_ONCE' (case insensitive).
        """
        return pulumi.get(self, "threshold_occurrences")

    @_builtins.property
    @pulumi.getter(name="timeFunction")
    @_utilities.deprecated("""use `threshold_occurrences` attribute instead""")
    def time_function(self) -> Optional[_builtins.str]:
        """
        Valid values are: 'all' or 'any'
        """
        return pulumi.get(self, "time_function")


@pulumi.output_type
class NrqlAlertConditionWarningPrediction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "predictBy":
            suggest = "predict_by"
        elif key == "preferPredictionViolation":
            suggest = "prefer_prediction_violation"

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

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

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

    def __init__(__self__, *,
                 predict_by: Optional[_builtins.int] = None,
                 prefer_prediction_violation: Optional[_builtins.bool] = None):
        """
        :param _builtins.int predict_by: BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        :param _builtins.bool prefer_prediction_violation: BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        if predict_by is not None:
            pulumi.set(__self__, "predict_by", predict_by)
        if prefer_prediction_violation is not None:
            pulumi.set(__self__, "prefer_prediction_violation", prefer_prediction_violation)

    @_builtins.property
    @pulumi.getter(name="predictBy")
    def predict_by(self) -> Optional[_builtins.int]:
        """
        BETA PREVIEW: the `predict_by` field is in limited release and only enabled for preview on a per-account basis. - The duration, in seconds, that the prediction should look into the future.
        """
        return pulumi.get(self, "predict_by")

    @_builtins.property
    @pulumi.getter(name="preferPredictionViolation")
    def prefer_prediction_violation(self) -> Optional[_builtins.bool]:
        """
        BETA PREVIEW: the `prefer_prediction_violation` field is in limited release and only enabled for preview on a per-account basis. - If a prediction incident is open when a term's static threshold is breached by the actual signal, default behavior is to close the prediction incident and open a static incident. Setting `prefer_prediction_violation` to `true` overrides this behavior leaving the prediction incident open and preventing a static incident from opening.
        """
        return pulumi.get(self, "prefer_prediction_violation")


@pulumi.output_type
class ObfuscationRuleAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "expressionId":
            suggest = "expression_id"

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

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

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

    def __init__(__self__, *,
                 attributes: Sequence[_builtins.str],
                 expression_id: _builtins.str,
                 method: _builtins.str):
        """
        :param Sequence[_builtins.str] attributes: Attribute names for action. An empty list applies the action to all the attributes.
        :param _builtins.str expression_id: Expression Id for action.
        :param _builtins.str method: Obfuscation method to use. Methods for replacing obfuscated values are `HASH_SHA256` and `MASK`.
        """
        pulumi.set(__self__, "attributes", attributes)
        pulumi.set(__self__, "expression_id", expression_id)
        pulumi.set(__self__, "method", method)

    @_builtins.property
    @pulumi.getter
    def attributes(self) -> Sequence[_builtins.str]:
        """
        Attribute names for action. An empty list applies the action to all the attributes.
        """
        return pulumi.get(self, "attributes")

    @_builtins.property
    @pulumi.getter(name="expressionId")
    def expression_id(self) -> _builtins.str:
        """
        Expression Id for action.
        """
        return pulumi.get(self, "expression_id")

    @_builtins.property
    @pulumi.getter
    def method(self) -> _builtins.str:
        """
        Obfuscation method to use. Methods for replacing obfuscated values are `HASH_SHA256` and `MASK`.
        """
        return pulumi.get(self, "method")


@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: _builtins.str,
                 description: Optional[_builtins.str] = None,
                 guid: Optional[_builtins.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 _builtins.str name: The title of the dashboard.
        :param _builtins.str description: Brief text describing the dashboard.
        :param _builtins.str guid: The unique entity identifier of the dashboard page in New Relic.
        :param Sequence['OneDashboardPageWidgetAreaArgs'] widget_areas: An area widget.
        :param Sequence['OneDashboardPageWidgetBarArgs'] widget_bars: A bar widget.
        :param Sequence['OneDashboardPageWidgetBillboardArgs'] widget_billboards: A billboard widget.
        :param Sequence['OneDashboardPageWidgetBulletArgs'] widget_bullets: A bullet widget.
        :param Sequence['OneDashboardPageWidgetFunnelArgs'] widget_funnels: A funnel widget.
        :param Sequence['OneDashboardPageWidgetHeatmapArgs'] widget_heatmaps: A heatmap widget.
        :param Sequence['OneDashboardPageWidgetHistogramArgs'] widget_histograms: A histogram widget.
        :param Sequence['OneDashboardPageWidgetJsonArgs'] widget_jsons: A JSON widget.
        :param Sequence['OneDashboardPageWidgetLineArgs'] widget_lines: A line widget.
        :param Sequence['OneDashboardPageWidgetLogTableArgs'] widget_log_tables: A log table widget.
        :param Sequence['OneDashboardPageWidgetMarkdownArgs'] widget_markdowns: A markdown widget.
        :param Sequence['OneDashboardPageWidgetPyArgs'] widget_pies: A pie widget.
        :param Sequence['OneDashboardPageWidgetStackedBarArgs'] widget_stacked_bars: A stacked bar widget.
        :param Sequence['OneDashboardPageWidgetTableArgs'] widget_tables: A table widget.
        """
        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)

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

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

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

    @_builtins.property
    @pulumi.getter(name="widgetAreas")
    def widget_areas(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetArea']]:
        """
        An area widget.
        """
        return pulumi.get(self, "widget_areas")

    @_builtins.property
    @pulumi.getter(name="widgetBars")
    def widget_bars(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBar']]:
        """
        A bar widget.
        """
        return pulumi.get(self, "widget_bars")

    @_builtins.property
    @pulumi.getter(name="widgetBillboards")
    def widget_billboards(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboard']]:
        """
        A billboard widget.
        """
        return pulumi.get(self, "widget_billboards")

    @_builtins.property
    @pulumi.getter(name="widgetBullets")
    def widget_bullets(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBullet']]:
        """
        A bullet widget.
        """
        return pulumi.get(self, "widget_bullets")

    @_builtins.property
    @pulumi.getter(name="widgetFunnels")
    def widget_funnels(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnel']]:
        """
        A funnel widget.
        """
        return pulumi.get(self, "widget_funnels")

    @_builtins.property
    @pulumi.getter(name="widgetHeatmaps")
    def widget_heatmaps(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmap']]:
        """
        A heatmap widget.
        """
        return pulumi.get(self, "widget_heatmaps")

    @_builtins.property
    @pulumi.getter(name="widgetHistograms")
    def widget_histograms(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogram']]:
        """
        A histogram widget.
        """
        return pulumi.get(self, "widget_histograms")

    @_builtins.property
    @pulumi.getter(name="widgetJsons")
    def widget_jsons(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJson']]:
        """
        A JSON widget.
        """
        return pulumi.get(self, "widget_jsons")

    @_builtins.property
    @pulumi.getter(name="widgetLines")
    def widget_lines(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLine']]:
        """
        A line widget.
        """
        return pulumi.get(self, "widget_lines")

    @_builtins.property
    @pulumi.getter(name="widgetLogTables")
    def widget_log_tables(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTable']]:
        """
        A log table widget.
        """
        return pulumi.get(self, "widget_log_tables")

    @_builtins.property
    @pulumi.getter(name="widgetMarkdowns")
    def widget_markdowns(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdown']]:
        """
        A markdown widget.
        """
        return pulumi.get(self, "widget_markdowns")

    @_builtins.property
    @pulumi.getter(name="widgetPies")
    def widget_pies(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPy']]:
        """
        A pie widget.
        """
        return pulumi.get(self, "widget_pies")

    @_builtins.property
    @pulumi.getter(name="widgetStackedBars")
    def widget_stacked_bars(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBar']]:
        """
        A stacked bar widget.
        """
        return pulumi.get(self, "widget_stacked_bars")

    @_builtins.property
    @pulumi.getter(name="widgetTables")
    def widget_tables(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTable']]:
        """
        A table widget.
        """
        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 == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetAreaNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetAreaColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetAreaDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetAreaInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetAreaNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 tooltip: Optional['outputs.OneDashboardPageWidgetAreaTooltip'] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetAreaUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetAreaNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetAreaColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetAreaDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetAreaInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetAreaNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param 'OneDashboardPageWidgetAreaTooltipArgs' tooltip: (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        :param Sequence['OneDashboardPageWidgetAreaUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if tooltip is not None:
            pulumi.set(__self__, "tooltip", tooltip)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetAreaNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetAreaInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def tooltip(self) -> Optional['outputs.OneDashboardPageWidgetAreaTooltip']:
        """
        (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        """
        return pulumi.get(self, "tooltip")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetAreaColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetAreaColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetAreaColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetAreaColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetAreaDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetAreaInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetAreaNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetAreaNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetAreaNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetAreaNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetAreaTooltip(dict):
    def __init__(__self__, *,
                 mode: _builtins.str):
        """
        :param _builtins.str mode: (Required) The tooltip display mode. Valid values are:
        """
        pulumi.set(__self__, "mode", mode)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        (Required) The tooltip display mode. Valid values are:
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class OneDashboardPageWidgetAreaUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetAreaUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetAreaUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetAreaUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetAreaUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBar(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBarNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetBarColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetBarDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 filter_current_dashboard: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetBarInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 linked_entity_guids: Optional[Sequence[_builtins.str]] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetBarNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetBarUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetBarNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetBarColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetBarDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.bool filter_current_dashboard: (Optional) Use this item to filter the current dashboard.
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetBarInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence[_builtins.str] linked_entity_guids: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        :param Sequence['OneDashboardPageWidgetBarNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetBarUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBarNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

    @_builtins.property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[_builtins.bool]:
        """
        (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "filter_current_dashboard")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetBarInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

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

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetBarColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBarColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetBarColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBarColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBarDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetBarInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetBarNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBarNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetBarNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBarNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBarUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBarUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetBarUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBarUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBarUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBillboard(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "billboardSettings":
            suggest = "billboard_settings"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBillboardNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 billboard_settings: Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettings'] = None,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardColor']] = None,
                 critical: Optional[_builtins.str] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetBillboardInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardUnit']] = None,
                 warning: Optional[_builtins.str] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetBillboardNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param 'OneDashboardPageWidgetBillboardBillboardSettingsArgs' billboard_settings: (Optional) A nested block that describes billboard specific settings. See Nested billboard\\_settings blocks below for details.
        :param Sequence['OneDashboardPageWidgetBillboardColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param _builtins.str critical: (Optional) Threshold above which the displayed value will be styled with a red color.
        :param Sequence['OneDashboardPageWidgetBillboardDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetBillboardInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetBillboardNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetBillboardUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.str warning: (Optional) Threshold above which the displayed value will be styled with a yellow color.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if billboard_settings is not None:
            pulumi.set(__self__, "billboard_settings", billboard_settings)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if critical is not None:
            pulumi.set(__self__, "critical", critical)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if warning is not None:
            pulumi.set(__self__, "warning", warning)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBillboardNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter(name="billboardSettings")
    def billboard_settings(self) -> Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettings']:
        """
        (Optional) A nested block that describes billboard specific settings. See Nested billboard\\_settings blocks below for details.
        """
        return pulumi.get(self, "billboard_settings")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

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

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetBillboardInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetBillboardBillboardSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gridOptions":
            suggest = "grid_options"

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

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

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

    def __init__(__self__, *,
                 grid_options: Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsGridOptions'] = None,
                 link: Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsLink'] = None,
                 visual: Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsVisual'] = None):
        """
        :param 'OneDashboardPageWidgetBillboardBillboardSettingsGridOptionsArgs' grid_options: (Optional) A nested block that configures grid layout options for the billboard widget. This block supports:
        :param 'OneDashboardPageWidgetBillboardBillboardSettingsLinkArgs' link: (Optional) A nested block that configures clickable links for the billboard widget. This block supports:
        :param 'OneDashboardPageWidgetBillboardBillboardSettingsVisualArgs' visual: (Optional) A nested block that configures the visual settings of the billboard widget. This block supports:
        """
        if grid_options is not None:
            pulumi.set(__self__, "grid_options", grid_options)
        if link is not None:
            pulumi.set(__self__, "link", link)
        if visual is not None:
            pulumi.set(__self__, "visual", visual)

    @_builtins.property
    @pulumi.getter(name="gridOptions")
    def grid_options(self) -> Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsGridOptions']:
        """
        (Optional) A nested block that configures grid layout options for the billboard widget. This block supports:
        """
        return pulumi.get(self, "grid_options")

    @_builtins.property
    @pulumi.getter
    def link(self) -> Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsLink']:
        """
        (Optional) A nested block that configures clickable links for the billboard widget. This block supports:
        """
        return pulumi.get(self, "link")

    @_builtins.property
    @pulumi.getter
    def visual(self) -> Optional['outputs.OneDashboardPageWidgetBillboardBillboardSettingsVisual']:
        """
        (Optional) A nested block that configures the visual settings of the billboard widget. This block supports:
        """
        return pulumi.get(self, "visual")


@pulumi.output_type
class OneDashboardPageWidgetBillboardBillboardSettingsGridOptions(dict):
    def __init__(__self__, *,
                 columns: Optional[_builtins.int] = None,
                 label: Optional[_builtins.int] = None,
                 value: Optional[_builtins.int] = None):
        """
        :param _builtins.int columns: (Optional) Number of columns to use for the grid layout.
        :param _builtins.int label: (Optional) Grid configuration for label.
        :param _builtins.int value: (Required) A possible variable value
        """
        if columns is not None:
            pulumi.set(__self__, "columns", columns)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def columns(self) -> Optional[_builtins.int]:
        """
        (Optional) Number of columns to use for the grid layout.
        """
        return pulumi.get(self, "columns")

    @_builtins.property
    @pulumi.getter
    def label(self) -> Optional[_builtins.int]:
        """
        (Optional) Grid configuration for label.
        """
        return pulumi.get(self, "label")

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[_builtins.int]:
        """
        (Required) A possible variable value
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class OneDashboardPageWidgetBillboardBillboardSettingsLink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "newTab":
            suggest = "new_tab"

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

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

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

    def __init__(__self__, *,
                 new_tab: Optional[_builtins.bool] = None,
                 title: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None):
        """
        :param _builtins.bool new_tab: (Optional) Boolean value indicating whether the link should open in a new tab. Defaults to `false`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param _builtins.str url: (Optional) The URL to navigate to when the billboard is clicked.
        """
        if new_tab is not None:
            pulumi.set(__self__, "new_tab", new_tab)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="newTab")
    def new_tab(self) -> Optional[_builtins.bool]:
        """
        (Optional) Boolean value indicating whether the link should open in a new tab. Defaults to `false`.
        """
        return pulumi.get(self, "new_tab")

    @_builtins.property
    @pulumi.getter
    def title(self) -> Optional[_builtins.str]:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        """
        (Optional) The URL to navigate to when the billboard is clicked.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class OneDashboardPageWidgetBillboardBillboardSettingsVisual(dict):
    def __init__(__self__, *,
                 alignment: Optional[_builtins.str] = None,
                 display: Optional[_builtins.str] = None):
        """
        :param _builtins.str alignment: (Optional) Controls the alignment of the billboard content. Accepted values are `inline` or `stacked`.
        :param _builtins.str display: (Optional) Controls how the billboard content is displayed. Accepted values are `auto`, `all`, `none`, `label` or `value`.
        """
        if alignment is not None:
            pulumi.set(__self__, "alignment", alignment)
        if display is not None:
            pulumi.set(__self__, "display", display)

    @_builtins.property
    @pulumi.getter
    def alignment(self) -> Optional[_builtins.str]:
        """
        (Optional) Controls the alignment of the billboard content. Accepted values are `inline` or `stacked`.
        """
        return pulumi.get(self, "alignment")

    @_builtins.property
    @pulumi.getter
    def display(self) -> Optional[_builtins.str]:
        """
        (Optional) Controls how the billboard content is displayed. Accepted values are `auto`, `all`, `none`, `label` or `value`.
        """
        return pulumi.get(self, "display")


@pulumi.output_type
class OneDashboardPageWidgetBillboardColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetBillboardColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBillboardColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBillboardDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetBillboardInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetBillboardNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetBillboardNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBillboardNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBillboardUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBillboardUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetBillboardUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBillboardUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBillboardUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBullet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 limit: _builtins.float,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetBulletNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetBulletColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetBulletDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetBulletInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetBulletNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetBulletUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param _builtins.float limit: (Required) Visualization limit for the widget.
        :param Sequence['OneDashboardPageWidgetBulletNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetBulletColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetBulletDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetBulletInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetBulletNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetBulletUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        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 colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetBulletNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetBulletInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetBulletColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBulletColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetBulletColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBulletColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBulletDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetBulletInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetBulletNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBulletNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetBulletNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetBulletNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetBulletUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetBulletUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetBulletUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetBulletUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetBulletUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetFunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetFunnelNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetFunnelInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetFunnelNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetFunnelColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetFunnelDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetFunnelInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetFunnelNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetFunnelUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetFunnelNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetFunnelInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetFunnelColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetFunnelColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetFunnelColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetFunnelDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetFunnelInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetFunnelNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetFunnelNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetFunnelNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetFunnelUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetFunnelUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetFunnelUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetFunnelUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetFunnelUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetHeatmap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetHeatmapNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 filter_current_dashboard: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetHeatmapInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 linked_entity_guids: Optional[Sequence[_builtins.str]] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetHeatmapNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetHeatmapColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetHeatmapDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.bool filter_current_dashboard: (Optional) Use this item to filter the current dashboard.
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetHeatmapInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence[_builtins.str] linked_entity_guids: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        :param Sequence['OneDashboardPageWidgetHeatmapNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetHeatmapUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetHeatmapNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

    @_builtins.property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[_builtins.bool]:
        """
        (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "filter_current_dashboard")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetHeatmapInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

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

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetHeatmapColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetHeatmapNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetHeatmapNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetHeatmapUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHeatmapUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetHeatmapUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetHistogram(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetHistogramNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetHistogramInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetHistogramNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetHistogramColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetHistogramDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetHistogramInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetHistogramNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetHistogramUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetHistogramNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetHistogramInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetHistogramColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetHistogramColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetHistogramColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetHistogramDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetHistogramInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetHistogramNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetHistogramNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetHistogramNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetHistogramUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetHistogramUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetHistogramUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetHistogramUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetHistogramUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetJson(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetJsonNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetJsonColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetJsonDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetJsonInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetJsonNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetJsonUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetJsonNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetJsonColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetJsonDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetJsonInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetJsonNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetJsonUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetJsonNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetJsonInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetJsonColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetJsonColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetJsonColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetJsonColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetJsonDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetJsonInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetJsonNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetJsonNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetJsonNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetJsonNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetJsonUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetJsonUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetJsonUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetJsonUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetJsonUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetLine(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "isLabelVisible":
            suggest = "is_label_visible"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"
        elif key == "yAxisLeftZero":
            suggest = "y_axis_left_zero"
        elif key == "yAxisRight":
            suggest = "y_axis_right"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetLineNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetLineColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetLineDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetLineInitialSorting'] = None,
                 is_label_visible: Optional[_builtins.bool] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetLineNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 thresholds: Optional[Sequence['outputs.OneDashboardPageWidgetLineThreshold']] = None,
                 tooltip: Optional['outputs.OneDashboardPageWidgetLineTooltip'] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetLineUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None,
                 y_axis_left_zero: Optional[_builtins.bool] = None,
                 y_axis_right: Optional['outputs.OneDashboardPageWidgetLineYAxisRight'] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetLineNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetLineColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetLineDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetLineInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool is_label_visible: (Optional) A boolean value, which when true, sets the label to be visibly displayed within thresholds. In other words, if this attribute is set to true, the _label always visible_ toggle in the _Thresholds_ section in the settings of the widget is enabled.
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetLineNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetLineThresholdArgs'] thresholds: (Optional) An attribute that helps specify multiple thresholds, each inclusive of a range of values between which the threshold would need to function, the name of the threshold and its severity. Multiple thresholds can be defined in a table widget. The `threshold` attribute requires specifying the following attributes in a nested block -
        :param 'OneDashboardPageWidgetLineTooltipArgs' tooltip: (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        :param Sequence['OneDashboardPageWidgetLineUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        :param _builtins.bool y_axis_left_zero: (Optional) An attribute that specifies if the values on the graph to be rendered need to be fit to scale, or printed within the specified range from `y_axis_left_min` (or 0 if it is not defined) to `y_axis_left_max`. Use `y_axis_left_zero = true` with a combination of `y_axis_left_min` and `y_axis_left_max` to render values from 0 or the specified minimum to the maximum, and `y_axis_left_zero = false` to fit the graph to scale.
        :param 'OneDashboardPageWidgetLineYAxisRightArgs' y_axis_right: (Optional) An attribute which helps specify the configuration of the Y-Axis displayed on the right side of the line widget. This is a nested block, which includes the following attributes:
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if is_label_visible is not None:
            pulumi.set(__self__, "is_label_visible", is_label_visible)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if thresholds is not None:
            pulumi.set(__self__, "thresholds", thresholds)
        if tooltip is not None:
            pulumi.set(__self__, "tooltip", tooltip)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)
        if y_axis_left_zero is not None:
            pulumi.set(__self__, "y_axis_left_zero", y_axis_left_zero)
        if y_axis_right is not None:
            pulumi.set(__self__, "y_axis_right", y_axis_right)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetLineNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetLineInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="isLabelVisible")
    def is_label_visible(self) -> Optional[_builtins.bool]:
        """
        (Optional) A boolean value, which when true, sets the label to be visibly displayed within thresholds. In other words, if this attribute is set to true, the _label always visible_ toggle in the _Thresholds_ section in the settings of the widget is enabled.
        """
        return pulumi.get(self, "is_label_visible")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def thresholds(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineThreshold']]:
        """
        (Optional) An attribute that helps specify multiple thresholds, each inclusive of a range of values between which the threshold would need to function, the name of the threshold and its severity. Multiple thresholds can be defined in a table widget. The `threshold` attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "thresholds")

    @_builtins.property
    @pulumi.getter
    def tooltip(self) -> Optional['outputs.OneDashboardPageWidgetLineTooltip']:
        """
        (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        """
        return pulumi.get(self, "tooltip")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftZero")
    def y_axis_left_zero(self) -> Optional[_builtins.bool]:
        """
        (Optional) An attribute that specifies if the values on the graph to be rendered need to be fit to scale, or printed within the specified range from `y_axis_left_min` (or 0 if it is not defined) to `y_axis_left_max`. Use `y_axis_left_zero = true` with a combination of `y_axis_left_min` and `y_axis_left_max` to render values from 0 or the specified minimum to the maximum, and `y_axis_left_zero = false` to fit the graph to scale.
        """
        return pulumi.get(self, "y_axis_left_zero")

    @_builtins.property
    @pulumi.getter(name="yAxisRight")
    def y_axis_right(self) -> Optional['outputs.OneDashboardPageWidgetLineYAxisRight']:
        """
        (Optional) An attribute which helps specify the configuration of the Y-Axis displayed on the right side of the line widget. This is a nested block, which includes the following attributes:
        """
        return pulumi.get(self, "y_axis_right")


@pulumi.output_type
class OneDashboardPageWidgetLineColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLineColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetLineColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetLineColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetLineDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetLineInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetLineNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLineNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetLineNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetLineNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetLineThreshold(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 OneDashboardPageWidgetLineThreshold. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 from_: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 severity: Optional[_builtins.str] = None,
                 to: Optional[_builtins.str] = None):
        """
        :param _builtins.str from_: The value 'from' which the threshold would need to be applied.
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str severity: The severity of the threshold, which would affect the visual appearance of the threshold (such as its color) accordingly. The value of this attribute would need to be one of the following - `warning`, `severe`, `critical`, `success`, `unavailable` which correspond to the severity labels _Warning_, _Approaching critical_, _Critical_, _Good_, _Neutral_ in the dropdown that helps specify the severity of thresholds in table widgets in the UI, respectively.
        :param _builtins.str to: The value until which the threshold would need to be applied.
        """
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if to is not None:
            pulumi.set(__self__, "to", to)

    @_builtins.property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[_builtins.str]:
        """
        The value 'from' which the threshold would need to be applied.
        """
        return pulumi.get(self, "from_")

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

    @_builtins.property
    @pulumi.getter
    def severity(self) -> Optional[_builtins.str]:
        """
        The severity of the threshold, which would affect the visual appearance of the threshold (such as its color) accordingly. The value of this attribute would need to be one of the following - `warning`, `severe`, `critical`, `success`, `unavailable` which correspond to the severity labels _Warning_, _Approaching critical_, _Critical_, _Good_, _Neutral_ in the dropdown that helps specify the severity of thresholds in table widgets in the UI, respectively.
        """
        return pulumi.get(self, "severity")

    @_builtins.property
    @pulumi.getter
    def to(self) -> Optional[_builtins.str]:
        """
        The value until which the threshold would need to be applied.
        """
        return pulumi.get(self, "to")


@pulumi.output_type
class OneDashboardPageWidgetLineTooltip(dict):
    def __init__(__self__, *,
                 mode: _builtins.str):
        """
        :param _builtins.str mode: (Required) The tooltip display mode. Valid values are:
        """
        pulumi.set(__self__, "mode", mode)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        (Required) The tooltip display mode. Valid values are:
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class OneDashboardPageWidgetLineUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLineUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetLineUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLineUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetLineUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetLineYAxisRight(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "yAxisRightMax":
            suggest = "y_axis_right_max"
        elif key == "yAxisRightMin":
            suggest = "y_axis_right_min"
        elif key == "yAxisRightSeries":
            suggest = "y_axis_right_series"
        elif key == "yAxisRightZero":
            suggest = "y_axis_right_zero"

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

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

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

    def __init__(__self__, *,
                 y_axis_right_max: Optional[_builtins.float] = None,
                 y_axis_right_min: Optional[_builtins.float] = None,
                 y_axis_right_series: Optional[Sequence[_builtins.str]] = None,
                 y_axis_right_zero: Optional[_builtins.bool] = None):
        """
        :param _builtins.float y_axis_right_max: Minimum value of the range to be specified with the Y-Axis on the right of the line widget.
        :param _builtins.float y_axis_right_min: , `y_axis_right_max` - (Optional) Attributes which help specify a range of minimum and maximum values, which adjust the right Y axis to display the data within the specified minimum and maximum value for the axis.
        :param Sequence[_builtins.str] y_axis_right_series: (Optional) An attribute which takes a list of strings, specifying a selection of series' displayed in the line chart to be adjusted against the values of the right Y-axis.
        :param _builtins.bool y_axis_right_zero: (Optional) An attribute that specifies if the values on the graph to be rendered need to be fit to scale, or printed within the specified range from `y_axis_right_min` (or 0 if it is not defined) to `y_axis_right_max`. Use `y_axis_right_zero = true` with a combination of `y_axis_right_min` and `y_axis_right_max` to render values from 0 or the specified minimum to the maximum, and `y_axis_right_zero = false` to fit the graph to scale.
        """
        if y_axis_right_max is not None:
            pulumi.set(__self__, "y_axis_right_max", y_axis_right_max)
        if y_axis_right_min is not None:
            pulumi.set(__self__, "y_axis_right_min", y_axis_right_min)
        if y_axis_right_series is not None:
            pulumi.set(__self__, "y_axis_right_series", y_axis_right_series)
        if y_axis_right_zero is not None:
            pulumi.set(__self__, "y_axis_right_zero", y_axis_right_zero)

    @_builtins.property
    @pulumi.getter(name="yAxisRightMax")
    def y_axis_right_max(self) -> Optional[_builtins.float]:
        """
        Minimum value of the range to be specified with the Y-Axis on the right of the line widget.
        """
        return pulumi.get(self, "y_axis_right_max")

    @_builtins.property
    @pulumi.getter(name="yAxisRightMin")
    def y_axis_right_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_right_max` - (Optional) Attributes which help specify a range of minimum and maximum values, which adjust the right Y axis to display the data within the specified minimum and maximum value for the axis.
        """
        return pulumi.get(self, "y_axis_right_min")

    @_builtins.property
    @pulumi.getter(name="yAxisRightSeries")
    def y_axis_right_series(self) -> Optional[Sequence[_builtins.str]]:
        """
        (Optional) An attribute which takes a list of strings, specifying a selection of series' displayed in the line chart to be adjusted against the values of the right Y-axis.
        """
        return pulumi.get(self, "y_axis_right_series")

    @_builtins.property
    @pulumi.getter(name="yAxisRightZero")
    def y_axis_right_zero(self) -> Optional[_builtins.bool]:
        """
        (Optional) An attribute that specifies if the values on the graph to be rendered need to be fit to scale, or printed within the specified range from `y_axis_right_min` (or 0 if it is not defined) to `y_axis_right_max`. Use `y_axis_right_zero = true` with a combination of `y_axis_right_min` and `y_axis_right_max` to render values from 0 or the specified minimum to the maximum, and `y_axis_right_zero = false` to fit the graph to scale.
        """
        return pulumi.get(self, "y_axis_right_zero")


@pulumi.output_type
class OneDashboardPageWidgetLogTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetLogTableNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetLogTableInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetLogTableNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetLogTableColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetLogTableDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetLogTableInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetLogTableNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetLogTableUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetLogTableNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetLogTableInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetLogTableColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetLogTableColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetLogTableColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetLogTableDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetLogTableInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetLogTableNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetLogTableNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetLogTableNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetLogTableUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetLogTableUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetLogTableUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetLogTableUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetLogTableUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetMarkdown(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 row: _builtins.int,
                 text: _builtins.str,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetMarkdownInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str text: (Required) The markdown source to be rendered in the widget.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetMarkdownColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetMarkdownDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetMarkdownInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetMarkdownNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetMarkdownUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "text", text)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

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

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetMarkdownInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetMarkdownColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@pulumi.output_type
class OneDashboardPageWidgetMarkdownNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetMarkdownNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetMarkdownUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetMarkdownUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetMarkdownUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetPy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetPyNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetPyColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetPyDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 filter_current_dashboard: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetPyInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 linked_entity_guids: Optional[Sequence[_builtins.str]] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetPyNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetPyUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetPyNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetPyColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetPyDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.bool filter_current_dashboard: (Optional) Use this item to filter the current dashboard.
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetPyInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence[_builtins.str] linked_entity_guids: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        :param Sequence['OneDashboardPageWidgetPyNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetPyUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetPyNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

    @_builtins.property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[_builtins.bool]:
        """
        (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "filter_current_dashboard")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetPyInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

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

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetPyColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetPyColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetPyColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetPyColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetPyDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetPyInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetPyNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetPyNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetPyNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetPyNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetPyUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetPyUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetPyUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetPyUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetPyUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetStackedBar(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetStackedBarNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetStackedBarInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 tooltip: Optional['outputs.OneDashboardPageWidgetStackedBarTooltip'] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetStackedBarNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetStackedBarColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetStackedBarDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetStackedBarInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence['OneDashboardPageWidgetStackedBarNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param 'OneDashboardPageWidgetStackedBarTooltipArgs' tooltip: (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        :param Sequence['OneDashboardPageWidgetStackedBarUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if tooltip is not None:
            pulumi.set(__self__, "tooltip", tooltip)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetStackedBarNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetStackedBarInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def tooltip(self) -> Optional['outputs.OneDashboardPageWidgetStackedBarTooltip']:
        """
        (Optional) A nested block that describes tooltip configuration for area, line, and stacked bar widgets. See Nested tooltip blocks below for details.
        """
        return pulumi.get(self, "tooltip")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetStackedBarColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetStackedBarNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetStackedBarNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarTooltip(dict):
    def __init__(__self__, *,
                 mode: _builtins.str):
        """
        :param _builtins.str mode: (Required) The tooltip display mode. Valid values are:
        """
        pulumi.set(__self__, "mode", mode)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> _builtins.str:
        """
        (Required) The tooltip display mode. Valid values are:
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetStackedBarUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetStackedBarUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetStackedBarUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nrqlQueries":
            suggest = "nrql_queries"
        elif key == "dataFormats":
            suggest = "data_formats"
        elif key == "facetShowOtherSeries":
            suggest = "facet_show_other_series"
        elif key == "filterCurrentDashboard":
            suggest = "filter_current_dashboard"
        elif key == "ignoreTimeRange":
            suggest = "ignore_time_range"
        elif key == "initialSorting":
            suggest = "initial_sorting"
        elif key == "legendEnabled":
            suggest = "legend_enabled"
        elif key == "linkedEntityGuids":
            suggest = "linked_entity_guids"
        elif key == "nullValues":
            suggest = "null_values"
        elif key == "refreshRate":
            suggest = "refresh_rate"
        elif key == "yAxisLeftMax":
            suggest = "y_axis_left_max"
        elif key == "yAxisLeftMin":
            suggest = "y_axis_left_min"

        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: _builtins.int,
                 nrql_queries: Sequence['outputs.OneDashboardPageWidgetTableNrqlQuery'],
                 row: _builtins.int,
                 title: _builtins.str,
                 colors: Optional[Sequence['outputs.OneDashboardPageWidgetTableColor']] = None,
                 data_formats: Optional[Sequence['outputs.OneDashboardPageWidgetTableDataFormat']] = None,
                 facet_show_other_series: Optional[_builtins.bool] = None,
                 filter_current_dashboard: Optional[_builtins.bool] = None,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 initial_sorting: Optional['outputs.OneDashboardPageWidgetTableInitialSorting'] = None,
                 legend_enabled: Optional[_builtins.bool] = None,
                 linked_entity_guids: Optional[Sequence[_builtins.str]] = None,
                 null_values: Optional[Sequence['outputs.OneDashboardPageWidgetTableNullValue']] = None,
                 refresh_rate: Optional[_builtins.str] = None,
                 thresholds: Optional[Sequence['outputs.OneDashboardPageWidgetTableThreshold']] = None,
                 units: Optional[Sequence['outputs.OneDashboardPageWidgetTableUnit']] = None,
                 width: Optional[_builtins.int] = None,
                 y_axis_left_max: Optional[_builtins.float] = None,
                 y_axis_left_min: Optional[_builtins.float] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param Sequence['OneDashboardPageWidgetTableNrqlQueryArgs'] nrql_queries: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param Sequence['OneDashboardPageWidgetTableColorArgs'] colors: (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        :param Sequence['OneDashboardPageWidgetTableDataFormatArgs'] data_formats: (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        :param _builtins.bool facet_show_other_series: (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        :param _builtins.bool filter_current_dashboard: (Optional) Use this item to filter the current dashboard.
        :param _builtins.int height: (Optional) Height of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param 'OneDashboardPageWidgetTableInitialSortingArgs' initial_sorting: (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        :param _builtins.bool legend_enabled: (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        :param Sequence[_builtins.str] linked_entity_guids: (Optional) Related entity GUIDs. Currently only supports Dashboard entity GUIDs.
        :param Sequence['OneDashboardPageWidgetTableNullValueArgs'] null_values: (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        :param _builtins.str refresh_rate: (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        :param Sequence['OneDashboardPageWidgetTableThresholdArgs'] thresholds: (Optional) An attribute that helps specify multiple thresholds, each inclusive of a range of values between which the threshold would need to function, the name of the threshold and its severity. Multiple thresholds can be defined in a table widget. The `threshold` attribute requires specifying the following attributes in a nested block -
        :param Sequence['OneDashboardPageWidgetTableUnitArgs'] units: (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        :param _builtins.int width: (Optional) Width of the widget.  Valid values are `1` to `12` inclusive.  Defaults to `4`.
        :param _builtins.float y_axis_left_min: , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "nrql_queries", nrql_queries)
        pulumi.set(__self__, "row", row)
        pulumi.set(__self__, "title", title)
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if data_formats is not None:
            pulumi.set(__self__, "data_formats", data_formats)
        if facet_show_other_series is not None:
            pulumi.set(__self__, "facet_show_other_series", facet_show_other_series)
        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 initial_sorting is not None:
            pulumi.set(__self__, "initial_sorting", initial_sorting)
        if legend_enabled is not None:
            pulumi.set(__self__, "legend_enabled", legend_enabled)
        if linked_entity_guids is not None:
            pulumi.set(__self__, "linked_entity_guids", linked_entity_guids)
        if null_values is not None:
            pulumi.set(__self__, "null_values", null_values)
        if refresh_rate is not None:
            pulumi.set(__self__, "refresh_rate", refresh_rate)
        if thresholds is not None:
            pulumi.set(__self__, "thresholds", thresholds)
        if units is not None:
            pulumi.set(__self__, "units", units)
        if width is not None:
            pulumi.set(__self__, "width", width)
        if y_axis_left_max is not None:
            pulumi.set(__self__, "y_axis_left_max", y_axis_left_max)
        if y_axis_left_min is not None:
            pulumi.set(__self__, "y_axis_left_min", y_axis_left_min)

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

    @_builtins.property
    @pulumi.getter(name="nrqlQueries")
    def nrql_queries(self) -> Sequence['outputs.OneDashboardPageWidgetTableNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_queries")

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

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def colors(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableColor']]:
        """
        (Optional) A nested block that describes colors of your charts per series. See Nested Colors blocks below for details.
        """
        return pulumi.get(self, "colors")

    @_builtins.property
    @pulumi.getter(name="dataFormats")
    def data_formats(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableDataFormat']]:
        """
        (Optional) A nested block that describes data format. See Nested data_format blocks below for details.
        """
        return pulumi.get(self, "data_formats")

    @_builtins.property
    @pulumi.getter(name="facetShowOtherSeries")
    def facet_show_other_series(self) -> Optional[_builtins.bool]:
        """
        (Optional) Enable or disable the Other group in visualisations. The other group is used if a facet on a query returns more than 2000 items for bar charts, pie charts, and tables. The other group aggregates the rest of the facets. Defaults to `false`
        """
        return pulumi.get(self, "facet_show_other_series")

    @_builtins.property
    @pulumi.getter(name="filterCurrentDashboard")
    def filter_current_dashboard(self) -> Optional[_builtins.bool]:
        """
        (Optional) Use this item to filter the current dashboard.
        """
        return pulumi.get(self, "filter_current_dashboard")

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="initialSorting")
    def initial_sorting(self) -> Optional['outputs.OneDashboardPageWidgetTableInitialSorting']:
        """
        (Optional) An attribute that describes the sorting mechanism for the table. This attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "initial_sorting")

    @_builtins.property
    @pulumi.getter(name="legendEnabled")
    def legend_enabled(self) -> Optional[_builtins.bool]:
        """
        (Optional) With this turned on, the legend will be displayed. Defaults to `true`.
        """
        return pulumi.get(self, "legend_enabled")

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

    @_builtins.property
    @pulumi.getter(name="nullValues")
    def null_values(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableNullValue']]:
        """
        (Optional) A nested block that describes a Null Values. See Nested Null Values blocks below for details.
        """
        return pulumi.get(self, "null_values")

    @_builtins.property
    @pulumi.getter(name="refreshRate")
    def refresh_rate(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute determines the frequency for data refresh specified in milliseconds. Accepted values are `auto` for default value, `0` for no refresh, `5000` for 5 seconds, `30000` for 30 seconds, `60000` for 60 seconds, `300000` for 5 minutes, `1800000` for 30 minutes, `3600000` for 60 minute, `10800000` for 3 hours, `43200000` for 12 hours and `86400000` for 24 hours.
        """
        return pulumi.get(self, "refresh_rate")

    @_builtins.property
    @pulumi.getter
    def thresholds(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableThreshold']]:
        """
        (Optional) An attribute that helps specify multiple thresholds, each inclusive of a range of values between which the threshold would need to function, the name of the threshold and its severity. Multiple thresholds can be defined in a table widget. The `threshold` attribute requires specifying the following attributes in a nested block -
        """
        return pulumi.get(self, "thresholds")

    @_builtins.property
    @pulumi.getter
    def units(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableUnit']]:
        """
        (Optional) A nested block that describes units on your Y axis. See Nested Units blocks below for details.
        """
        return pulumi.get(self, "units")

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

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMax")
    def y_axis_left_max(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "y_axis_left_max")

    @_builtins.property
    @pulumi.getter(name="yAxisLeftMin")
    def y_axis_left_min(self) -> Optional[_builtins.float]:
        """
        , `y_axis_left_max` - (Optional) Adjust the Y axis to display the data within certain values by setting a minimum and maximum value for the axis for line charts and area charts. If no customization option is selected, dashboards automatically displays the full Y axis from 0 to the top value plus a margin.
        """
        return pulumi.get(self, "y_axis_left_min")


@pulumi.output_type
class OneDashboardPageWidgetTableColor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetTableColorSeriesOverride']] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param Sequence['OneDashboardPageWidgetTableColorSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableColorSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetTableColorSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 color: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str color: (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        :param _builtins.str series_name: Series name
        """
        if color is not None:
            pulumi.set(__self__, "color", color)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter
    def color(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a color to customize the color of your charts per series in area, bar, line, pie, and stacked bar charts. Accepted values are RGB, HEX, or HSL code.
        """
        return pulumi.get(self, "color")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


@pulumi.output_type
class OneDashboardPageWidgetTableDataFormat(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 type: _builtins.str,
                 format: Optional[_builtins.str] = None,
                 precision: Optional[_builtins.int] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param _builtins.str format: (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        :param _builtins.int precision: (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if precision is not None:
            pulumi.set(__self__, "precision", precision)

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter
    def format(self) -> Optional[_builtins.str]:
        """
        (Optional) This attribute is provided when the `name` is that of a column comprising date/time values and the `type` attribute is set to `custom` defining the specific date format to be applied to your data.
        """
        return pulumi.get(self, "format")

    @_builtins.property
    @pulumi.getter
    def precision(self) -> Optional[_builtins.int]:
        """
        (Optional) This attribute is utilized when the `type` attribute is set to `decimal`, stipulating the precise number of digits after the decimal point for your data.
        """
        return pulumi.get(self, "precision")


@pulumi.output_type
class OneDashboardPageWidgetTableInitialSorting(dict):
    def __init__(__self__, *,
                 direction: _builtins.str,
                 name: _builtins.str):
        """
        :param _builtins.str direction: (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        :param _builtins.str name: The title of the dashboard.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def direction(self) -> _builtins.str:
        """
        (Required) Defines the sort order. Accepted values are `asc` for ascending or `desc` for descending.
        """
        return pulumi.get(self, "direction")

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


@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: _builtins.str,
                 account_id: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str 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)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        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 OneDashboardPageWidgetTableNullValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetTableNullValueSeriesOverride']] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param Sequence['OneDashboardPageWidgetTableNullValueSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableNullValueSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")


@pulumi.output_type
class OneDashboardPageWidgetTableNullValueSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nullValue":
            suggest = "null_value"
        elif key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 null_value: Optional[_builtins.str] = None,
                 series_name: Optional[_builtins.str] = None):
        """
        :param _builtins.str null_value: Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        :param _builtins.str series_name: Series name
        """
        if null_value is not None:
            pulumi.set(__self__, "null_value", null_value)
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)

    @_builtins.property
    @pulumi.getter(name="nullValue")
    def null_value(self) -> Optional[_builtins.str]:
        """
        Choose an option in displaying null values. Accepted values are `default`, `remove`, `preserve`, or `zero`.
        """
        return pulumi.get(self, "null_value")

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")


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

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

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

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

    def __init__(__self__, *,
                 column_name: Optional[_builtins.str] = None,
                 from_: Optional[_builtins.str] = None,
                 severity: Optional[_builtins.str] = None,
                 to: Optional[_builtins.str] = None):
        """
        :param _builtins.str column_name: The name of the column in the table, to which the threshold would need to be applied.
        :param _builtins.str from_: The value 'from' which the threshold would need to be applied.
        :param _builtins.str severity: The severity of the threshold, which would affect the visual appearance of the threshold (such as its color) accordingly. The value of this attribute would need to be one of the following - `warning`, `severe`, `critical`, `success`, `unavailable` which correspond to the severity labels _Warning_, _Approaching critical_, _Critical_, _Good_, _Neutral_ in the dropdown that helps specify the severity of thresholds in table widgets in the UI, respectively.
        :param _builtins.str to: The value until which the threshold would need to be applied.
        """
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if to is not None:
            pulumi.set(__self__, "to", to)

    @_builtins.property
    @pulumi.getter(name="columnName")
    def column_name(self) -> Optional[_builtins.str]:
        """
        The name of the column in the table, to which the threshold would need to be applied.
        """
        return pulumi.get(self, "column_name")

    @_builtins.property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[_builtins.str]:
        """
        The value 'from' which the threshold would need to be applied.
        """
        return pulumi.get(self, "from_")

    @_builtins.property
    @pulumi.getter
    def severity(self) -> Optional[_builtins.str]:
        """
        The severity of the threshold, which would affect the visual appearance of the threshold (such as its color) accordingly. The value of this attribute would need to be one of the following - `warning`, `severe`, `critical`, `success`, `unavailable` which correspond to the severity labels _Warning_, _Approaching critical_, _Critical_, _Good_, _Neutral_ in the dropdown that helps specify the severity of thresholds in table widgets in the UI, respectively.
        """
        return pulumi.get(self, "severity")

    @_builtins.property
    @pulumi.getter
    def to(self) -> Optional[_builtins.str]:
        """
        The value until which the threshold would need to be applied.
        """
        return pulumi.get(self, "to")


@pulumi.output_type
class OneDashboardPageWidgetTableUnit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesOverrides":
            suggest = "series_overrides"

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

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

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

    def __init__(__self__, *,
                 series_overrides: Optional[Sequence['outputs.OneDashboardPageWidgetTableUnitSeriesOverride']] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param Sequence['OneDashboardPageWidgetTableUnitSeriesOverrideArgs'] series_overrides: (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_overrides is not None:
            pulumi.set(__self__, "series_overrides", series_overrides)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesOverrides")
    def series_overrides(self) -> Optional[Sequence['outputs.OneDashboardPageWidgetTableUnitSeriesOverride']]:
        """
        (Optional) A Nested block which will take two string attributes `color` and `series_name`. This nested block is used to customize colors of individual.
        """
        return pulumi.get(self, "series_overrides")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardPageWidgetTableUnitSeriesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seriesName":
            suggest = "series_name"

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

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

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

    def __init__(__self__, *,
                 series_name: Optional[_builtins.str] = None,
                 unit: Optional[_builtins.str] = None):
        """
        :param _builtins.str series_name: Series name
        :param _builtins.str unit: (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        if series_name is not None:
            pulumi.set(__self__, "series_name", series_name)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @_builtins.property
    @pulumi.getter(name="seriesName")
    def series_name(self) -> Optional[_builtins.str]:
        """
        Series name
        """
        return pulumi.get(self, "series_name")

    @_builtins.property
    @pulumi.getter
    def unit(self) -> Optional[_builtins.str]:
        """
        (Optional) Choose a unit to customize the unit on your Y axis and in each of your series.
        """
        return pulumi.get(self, "unit")


@pulumi.output_type
class OneDashboardRawPage(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 description: Optional[_builtins.str] = None,
                 guid: Optional[_builtins.str] = None,
                 widgets: Optional[Sequence['outputs.OneDashboardRawPageWidget']] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str description: Brief text describing the dashboard.
        :param _builtins.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)

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

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

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

    @_builtins.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: _builtins.int,
                 configuration: _builtins.str,
                 row: _builtins.int,
                 title: _builtins.str,
                 visualization_id: _builtins.str,
                 height: Optional[_builtins.int] = None,
                 id: Optional[_builtins.str] = None,
                 linked_entity_guids: Optional[Sequence[_builtins.str]] = None,
                 width: Optional[_builtins.int] = None):
        """
        :param _builtins.int column: (Required) Column position of widget from top left, starting at `1`.
        :param _builtins.str configuration: (Required) The configuration of the widget.
        :param _builtins.int row: (Required) Row position of widget from top left, starting at `1`.
        :param _builtins.str title: (Required) A title for the widget.
        :param _builtins.str visualization_id: (Required) The visualization ID of the widget
        :param _builtins.int height: (Optional) Height of the widget. Valid values are `1` to `12` inclusive. Defaults to `3`.
        :param _builtins.str id: The ID of the widget.
        :param Sequence[_builtins.str] linked_entity_guids: (Optional) Related entity GUIDs.
        :param _builtins.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)

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[_builtins.str]:
        """
        The ID of the widget.
        """
        return pulumi.get(self, "id")

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

    @_builtins.property
    @pulumi.getter
    def width(self) -> Optional[_builtins.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 OneDashboardVariable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "replacementStrategy":
            suggest = "replacement_strategy"
        elif key == "defaultValues":
            suggest = "default_values"
        elif key == "isMultiSelection":
            suggest = "is_multi_selection"
        elif key == "nrqlQuery":
            suggest = "nrql_query"

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

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

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

    def __init__(__self__, *,
                 name: _builtins.str,
                 replacement_strategy: _builtins.str,
                 title: _builtins.str,
                 type: _builtins.str,
                 default_values: Optional[Sequence[_builtins.str]] = None,
                 is_multi_selection: Optional[_builtins.bool] = None,
                 items: Optional[Sequence['outputs.OneDashboardVariableItem']] = None,
                 nrql_query: Optional['outputs.OneDashboardVariableNrqlQuery'] = None,
                 options: Optional[Sequence['outputs.OneDashboardVariableOption']] = None):
        """
        :param _builtins.str name: The title of the dashboard.
        :param _builtins.str replacement_strategy: (Optional) Indicates the strategy to apply when replacing a variable in a NRQL query. One of `default`, `identifier`, `number` or `string`.
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        :param _builtins.str type: (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        :param Sequence[_builtins.str] default_values: (Optional) A list of default values for this variable. To select **all** default values, the appropriate value to be used with this argument would be `["*"]`.
        :param _builtins.bool is_multi_selection: (Optional) Indicates whether this variable supports multiple selection or not. Only applies to variables of type `nrql` or `enum`.
        :param Sequence['OneDashboardVariableItemArgs'] items: (Optional) List of possible values for variables of type `enum`. See Nested item blocks below for details.
        :param 'OneDashboardVariableNrqlQueryArgs' nrql_query: (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        :param Sequence['OneDashboardVariableOptionArgs'] options: (Optional) Specifies additional options to be added to dashboard variables. Supports the following nested attribute(s) -
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "replacement_strategy", replacement_strategy)
        pulumi.set(__self__, "title", title)
        pulumi.set(__self__, "type", type)
        if default_values is not None:
            pulumi.set(__self__, "default_values", default_values)
        if is_multi_selection is not None:
            pulumi.set(__self__, "is_multi_selection", is_multi_selection)
        if items is not None:
            pulumi.set(__self__, "items", items)
        if nrql_query is not None:
            pulumi.set(__self__, "nrql_query", nrql_query)
        if options is not None:
            pulumi.set(__self__, "options", options)

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

    @_builtins.property
    @pulumi.getter(name="replacementStrategy")
    def replacement_strategy(self) -> _builtins.str:
        """
        (Optional) Indicates the strategy to apply when replacing a variable in a NRQL query. One of `default`, `identifier`, `number` or `string`.
        """
        return pulumi.get(self, "replacement_strategy")

    @_builtins.property
    @pulumi.getter
    def title(self) -> _builtins.str:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        (Required) Specifies the data type of the variable and where its possible values may come from. One of `enum`, `nrql` or `string`
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter(name="defaultValues")
    def default_values(self) -> Optional[Sequence[_builtins.str]]:
        """
        (Optional) A list of default values for this variable. To select **all** default values, the appropriate value to be used with this argument would be `["*"]`.
        """
        return pulumi.get(self, "default_values")

    @_builtins.property
    @pulumi.getter(name="isMultiSelection")
    def is_multi_selection(self) -> Optional[_builtins.bool]:
        """
        (Optional) Indicates whether this variable supports multiple selection or not. Only applies to variables of type `nrql` or `enum`.
        """
        return pulumi.get(self, "is_multi_selection")

    @_builtins.property
    @pulumi.getter
    def items(self) -> Optional[Sequence['outputs.OneDashboardVariableItem']]:
        """
        (Optional) List of possible values for variables of type `enum`. See Nested item blocks below for details.
        """
        return pulumi.get(self, "items")

    @_builtins.property
    @pulumi.getter(name="nrqlQuery")
    def nrql_query(self) -> Optional['outputs.OneDashboardVariableNrqlQuery']:
        """
        (Optional) Configuration for variables of type `nrql`. See Nested nrql\\_query blocks for Variables for details.
        """
        return pulumi.get(self, "nrql_query")

    @_builtins.property
    @pulumi.getter
    def options(self) -> Optional[Sequence['outputs.OneDashboardVariableOption']]:
        """
        (Optional) Specifies additional options to be added to dashboard variables. Supports the following nested attribute(s) -
        """
        return pulumi.get(self, "options")


@pulumi.output_type
class OneDashboardVariableItem(dict):
    def __init__(__self__, *,
                 value: _builtins.str,
                 title: Optional[_builtins.str] = None):
        """
        :param _builtins.str value: (Required) A possible variable value
        :param _builtins.str title: (Optional) A human-friendly display string for this value.
        """
        pulumi.set(__self__, "value", value)
        if title is not None:
            pulumi.set(__self__, "title", title)

    @_builtins.property
    @pulumi.getter
    def value(self) -> _builtins.str:
        """
        (Required) A possible variable value
        """
        return pulumi.get(self, "value")

    @_builtins.property
    @pulumi.getter
    def title(self) -> Optional[_builtins.str]:
        """
        (Optional) A human-friendly display string for this value.
        """
        return pulumi.get(self, "title")


@pulumi.output_type
class OneDashboardVariableNrqlQuery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountIds":
            suggest = "account_ids"

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

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

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

    def __init__(__self__, *,
                 query: _builtins.str,
                 account_ids: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.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 Sequence[_builtins.str] account_ids: (Required) List of account IDs such as `[12345, 67890]`.
        """
        pulumi.set(__self__, "query", query)
        if account_ids is not None:
            pulumi.set(__self__, "account_ids", account_ids)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter(name="accountIds")
    def account_ids(self) -> Optional[Sequence[_builtins.str]]:
        """
        (Required) List of account IDs such as `[12345, 67890]`.
        """
        return pulumi.get(self, "account_ids")


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

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

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

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

    def __init__(__self__, *,
                 excluded: Optional[_builtins.bool] = None,
                 ignore_time_range: Optional[_builtins.bool] = None,
                 show_apply_action: Optional[_builtins.bool] = None):
        """
        :param _builtins.bool excluded: (Optional) An argument with a boolean value. With this turned on, the query condition defined with the variable will not be included in the query. Defaults to `false`.
        :param _builtins.bool ignore_time_range: (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        :param _builtins.bool show_apply_action: (Optional) When multi-selection is enabled (`is_multi_selection = true`), displays an "Apply" button that allows users to confirm and apply their selected values to the dashboard.
        """
        if excluded is not None:
            pulumi.set(__self__, "excluded", excluded)
        if ignore_time_range is not None:
            pulumi.set(__self__, "ignore_time_range", ignore_time_range)
        if show_apply_action is not None:
            pulumi.set(__self__, "show_apply_action", show_apply_action)

    @_builtins.property
    @pulumi.getter
    def excluded(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value. With this turned on, the query condition defined with the variable will not be included in the query. Defaults to `false`.
        """
        return pulumi.get(self, "excluded")

    @_builtins.property
    @pulumi.getter(name="ignoreTimeRange")
    def ignore_time_range(self) -> Optional[_builtins.bool]:
        """
        (Optional) An argument with a boolean value that is supported only by variables of `type` _nrql_ - when true, the time range specified in the query will override the time picker on dashboards and other pages.
        """
        return pulumi.get(self, "ignore_time_range")

    @_builtins.property
    @pulumi.getter(name="showApplyAction")
    def show_apply_action(self) -> Optional[_builtins.bool]:
        """
        (Optional) When multi-selection is enabled (`is_multi_selection = true`), displays an "Apply" button that allows users to confirm and apply their selected values to the dashboard.
        """
        return pulumi.get(self, "show_apply_action")


@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: _builtins.str,
                 valid_events: 'outputs.ServiceLevelEventsValidEvents',
                 bad_events: Optional['outputs.ServiceLevelEventsBadEvents'] = None,
                 good_events: Optional['outputs.ServiceLevelEventsGoodEvents'] = None):
        """
        :param _builtins.str 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)

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> _builtins.str:
        """
        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")

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

    @_builtins.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")

    @_builtins.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_: _builtins.str,
                 select: Optional['outputs.ServiceLevelEventsBadEventsSelect'] = None,
                 where: Optional[_builtins.str] = None):
        """
        :param _builtins.str from_: The event type where NRDB data will be fetched from.
        :param 'ServiceLevelEventsBadEventsSelectArgs' select: The NRQL SELECT clause to aggregate events.
        :param _builtins.str where: A filter that narrows down the NRDB events just to those that are considered bad responses (e.g, those that refer to
               a particular entity and returned an error).
        """
        pulumi.set(__self__, "from_", from_)
        if select is not None:
            pulumi.set(__self__, "select", select)
        if where is not None:
            pulumi.set(__self__, "where", where)

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

    @_builtins.property
    @pulumi.getter
    def select(self) -> Optional['outputs.ServiceLevelEventsBadEventsSelect']:
        """
        The NRQL SELECT clause to aggregate events.
        """
        return pulumi.get(self, "select")

    @_builtins.property
    @pulumi.getter
    def where(self) -> Optional[_builtins.str]:
        """
        A filter that narrows down the NRDB events just to those that are considered bad responses (e.g, those that refer to
        a particular entity and returned an error).
        """
        return pulumi.get(self, "where")


@pulumi.output_type
class ServiceLevelEventsBadEventsSelect(dict):
    def __init__(__self__, *,
                 function: _builtins.str,
                 attribute: Optional[_builtins.str] = None,
                 threshold: Optional[_builtins.float] = None):
        """
        :param _builtins.str function: The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        :param _builtins.str attribute: The event attribute to use in the SELECT clause.
        :param _builtins.float threshold: Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        pulumi.set(__self__, "function", function)
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @_builtins.property
    @pulumi.getter
    def function(self) -> _builtins.str:
        """
        The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        """
        return pulumi.get(self, "function")

    @_builtins.property
    @pulumi.getter
    def attribute(self) -> Optional[_builtins.str]:
        """
        The event attribute to use in the SELECT clause.
        """
        return pulumi.get(self, "attribute")

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> Optional[_builtins.float]:
        """
        Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        return pulumi.get(self, "threshold")


@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_: _builtins.str,
                 select: Optional['outputs.ServiceLevelEventsGoodEventsSelect'] = None,
                 where: Optional[_builtins.str] = None):
        """
        :param _builtins.str from_: The event type where NRDB data will be fetched from.
        :param 'ServiceLevelEventsGoodEventsSelectArgs' select: The NRQL SELECT clause to aggregate events.
        :param _builtins.str where: A filter that narrows down the NRDB events just to those that are considered good responses (e.g, those that refer to
               a particular entity and were successful).
        """
        pulumi.set(__self__, "from_", from_)
        if select is not None:
            pulumi.set(__self__, "select", select)
        if where is not None:
            pulumi.set(__self__, "where", where)

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

    @_builtins.property
    @pulumi.getter
    def select(self) -> Optional['outputs.ServiceLevelEventsGoodEventsSelect']:
        """
        The NRQL SELECT clause to aggregate events.
        """
        return pulumi.get(self, "select")

    @_builtins.property
    @pulumi.getter
    def where(self) -> Optional[_builtins.str]:
        """
        A filter that narrows down the NRDB events just to those that are considered good responses (e.g, those that refer to
        a particular entity and were successful).
        """
        return pulumi.get(self, "where")


@pulumi.output_type
class ServiceLevelEventsGoodEventsSelect(dict):
    def __init__(__self__, *,
                 function: _builtins.str,
                 attribute: Optional[_builtins.str] = None,
                 threshold: Optional[_builtins.float] = None):
        """
        :param _builtins.str function: The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        :param _builtins.str attribute: The event attribute to use in the SELECT clause.
        :param _builtins.float threshold: Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        pulumi.set(__self__, "function", function)
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @_builtins.property
    @pulumi.getter
    def function(self) -> _builtins.str:
        """
        The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        """
        return pulumi.get(self, "function")

    @_builtins.property
    @pulumi.getter
    def attribute(self) -> Optional[_builtins.str]:
        """
        The event attribute to use in the SELECT clause.
        """
        return pulumi.get(self, "attribute")

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> Optional[_builtins.float]:
        """
        Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        return pulumi.get(self, "threshold")


@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_: _builtins.str,
                 select: Optional['outputs.ServiceLevelEventsValidEventsSelect'] = None,
                 where: Optional[_builtins.str] = None):
        """
        :param _builtins.str from_: The event type where NRDB data will be fetched from.
        :param 'ServiceLevelEventsValidEventsSelectArgs' select: The NRQL SELECT clause to aggregate events.
        :param _builtins.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).
        """
        pulumi.set(__self__, "from_", from_)
        if select is not None:
            pulumi.set(__self__, "select", select)
        if where is not None:
            pulumi.set(__self__, "where", where)

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

    @_builtins.property
    @pulumi.getter
    def select(self) -> Optional['outputs.ServiceLevelEventsValidEventsSelect']:
        """
        The NRQL SELECT clause to aggregate events.
        """
        return pulumi.get(self, "select")

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


@pulumi.output_type
class ServiceLevelEventsValidEventsSelect(dict):
    def __init__(__self__, *,
                 function: _builtins.str,
                 attribute: Optional[_builtins.str] = None,
                 threshold: Optional[_builtins.float] = None):
        """
        :param _builtins.str function: The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        :param _builtins.str attribute: The event attribute to use in the SELECT clause.
        :param _builtins.float threshold: Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        pulumi.set(__self__, "function", function)
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @_builtins.property
    @pulumi.getter
    def function(self) -> _builtins.str:
        """
        The function to use in the SELECT clause. Valid values are `COUNT`, `SUM`, `GET_FIELD`, and `GET_CDF_COUNT`.
        """
        return pulumi.get(self, "function")

    @_builtins.property
    @pulumi.getter
    def attribute(self) -> Optional[_builtins.str]:
        """
        The event attribute to use in the SELECT clause.
        """
        return pulumi.get(self, "attribute")

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> Optional[_builtins.float]:
        """
        Limit for values to be counter by `GET_CDF_COUNT` function.
        """
        return pulumi.get(self, "threshold")


@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: _builtins.float,
                 time_window: 'outputs.ServiceLevelObjectiveTimeWindow',
                 description: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.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 _builtins.str description: The description of the SLI.
        :param _builtins.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)

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

    @_builtins.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")

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

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.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)

    @_builtins.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: _builtins.int,
                 unit: _builtins.str):
        """
        :param _builtins.int count: Valid values are `1`, `7` and `28`.
        :param _builtins.str unit: The only supported value is `DAY`.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "unit", unit)

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

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


@pulumi.output_type
class WorkflowDestination(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelId":
            suggest = "channel_id"
        elif key == "notificationTriggers":
            suggest = "notification_triggers"
        elif key == "updateOriginalMessage":
            suggest = "update_original_message"

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

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

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

    def __init__(__self__, *,
                 channel_id: _builtins.str,
                 name: Optional[_builtins.str] = None,
                 notification_triggers: Optional[Sequence[_builtins.str]] = None,
                 type: Optional[_builtins.str] = None,
                 update_original_message: Optional[_builtins.bool] = None):
        """
        :param _builtins.str channel_id: (Required) Destination's channel id.
        :param _builtins.str name: The name of the workflow.
        :param Sequence[_builtins.str] notification_triggers: List of triggers to notify about in this destination configuration.
        :param _builtins.str type: (Required) The type of the destination. One of: (EMAIL, EVENT_BRIDGE, PAGERDUTY_ACCOUNT_INTEGRATION, PAGERDUTY_SERVICE_INTEGRATION, SERVICE_NOW, SERVICE_NOW_APP, WEBHOOK, MOBILE_PUSH, SLACK, JIRA, MICROSOFT_TEAMS, WORKFLOW_AUTOMATION).
        :param _builtins.bool update_original_message: Update original notification message (Slack channels only)
        """
        pulumi.set(__self__, "channel_id", channel_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if notification_triggers is not None:
            pulumi.set(__self__, "notification_triggers", notification_triggers)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if update_original_message is not None:
            pulumi.set(__self__, "update_original_message", update_original_message)

    @_builtins.property
    @pulumi.getter(name="channelId")
    def channel_id(self) -> _builtins.str:
        """
        (Required) Destination's channel id.
        """
        return pulumi.get(self, "channel_id")

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

    @_builtins.property
    @pulumi.getter(name="notificationTriggers")
    def notification_triggers(self) -> Optional[Sequence[_builtins.str]]:
        """
        List of triggers to notify about in this destination configuration.
        """
        return pulumi.get(self, "notification_triggers")

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[_builtins.str]:
        """
        (Required) The type of the destination. One of: (EMAIL, EVENT_BRIDGE, PAGERDUTY_ACCOUNT_INTEGRATION, PAGERDUTY_SERVICE_INTEGRATION, SERVICE_NOW, SERVICE_NOW_APP, WEBHOOK, MOBILE_PUSH, SLACK, JIRA, MICROSOFT_TEAMS, WORKFLOW_AUTOMATION).
        """
        return pulumi.get(self, "type")

    @_builtins.property
    @pulumi.getter(name="updateOriginalMessage")
    def update_original_message(self) -> Optional[_builtins.bool]:
        """
        Update original notification message (Slack channels only)
        """
        return pulumi.get(self, "update_original_message")


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

    @_builtins.property
    @pulumi.getter
    def nrqls(self) -> Sequence['outputs.WorkflowEnrichmentsNrql']:
        """
        (Required) Nrql type Enrichments.
        """
        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: _builtins.str,
                 account_id: Optional[_builtins.str] = None,
                 enrichment_id: Optional[_builtins.str] = None,
                 type: Optional[_builtins.str] = None):
        """
        :param Sequence['WorkflowEnrichmentsNrqlConfigurationArgs'] configurations: A set of key-value pairs to represent a enrichment configuration.
        :param _builtins.str name: The name of the workflow.
        :param _builtins.str account_id: Determines the New Relic account in which the workflow is created. Defaults to the account defined in the provider section.
        :param _builtins.str enrichment_id: Enrichment's id.
        :param _builtins.str type: The type of the enrichment. One of: (NRQL).
        """
        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)

    @_builtins.property
    @pulumi.getter
    def configurations(self) -> Sequence['outputs.WorkflowEnrichmentsNrqlConfiguration']:
        """
        A set of key-value pairs to represent a enrichment configuration.
        """
        return pulumi.get(self, "configurations")

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

    @_builtins.property
    @pulumi.getter(name="accountId")
    def account_id(self) -> Optional[_builtins.str]:
        """
        Determines the New Relic account in which the workflow is created. Defaults to the account defined in the provider section.
        """
        return pulumi.get(self, "account_id")

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[_builtins.str]:
        """
        The type of the enrichment. One of: (NRQL).
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class WorkflowEnrichmentsNrqlConfiguration(dict):
    def __init__(__self__, *,
                 query: _builtins.str):
        """
        :param _builtins.str query: enrichment's NRQL query
        """
        pulumi.set(__self__, "query", query)

    @_builtins.property
    @pulumi.getter
    def query(self) -> _builtins.str:
        """
        enrichment's 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: _builtins.str,
                 type: _builtins.str,
                 filter_id: Optional[_builtins.str] = None,
                 predicates: Optional[Sequence['outputs.WorkflowIssuesFilterPredicate']] = None):
        """
        :param _builtins.str name: (Required) Filter's name.
        :param _builtins.str type: Type of the filter. Please just set this field to `FILTER`. The field is likely to be deprecated/removed in the near future.
        :param _builtins.str filter_id: filter id.
        :param Sequence['WorkflowIssuesFilterPredicateArgs'] predicates: A condition an issue event should satisfy to be processed by the workflow
        """
        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)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        (Required) Filter's name.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def type(self) -> _builtins.str:
        """
        Type of the filter. Please just set this field to `FILTER`. The field is likely to be deprecated/removed in the near future.
        """
        return pulumi.get(self, "type")

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

    @_builtins.property
    @pulumi.getter
    def predicates(self) -> Optional[Sequence['outputs.WorkflowIssuesFilterPredicate']]:
        """
        A condition an issue event should satisfy to be processed by the workflow
        """
        return pulumi.get(self, "predicates")


@pulumi.output_type
class WorkflowIssuesFilterPredicate(dict):
    def __init__(__self__, *,
                 attribute: _builtins.str,
                 operator: _builtins.str,
                 values: Sequence[_builtins.str]):
        """
        :param _builtins.str attribute: Issue event attribute to check
        :param _builtins.str operator: An operator to use to compare the attribute with the provided `values`, see supported operators below
        :param Sequence[_builtins.str] values: The `attribute` must match **any** of the values in this list
        """
        pulumi.set(__self__, "attribute", attribute)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @_builtins.property
    @pulumi.getter
    def attribute(self) -> _builtins.str:
        """
        Issue event attribute to check
        """
        return pulumi.get(self, "attribute")

    @_builtins.property
    @pulumi.getter
    def operator(self) -> _builtins.str:
        """
        An operator to use to compare the attribute with the provided `values`, see supported operators below
        """
        return pulumi.get(self, "operator")

    @_builtins.property
    @pulumi.getter
    def values(self) -> Sequence[_builtins.str]:
        """
        The `attribute` must match **any** of the values in this list
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetAlertChannelConfigResult(dict):
    def __init__(__self__, *,
                 api_key: Optional[_builtins.str] = None,
                 auth_password: Optional[_builtins.str] = None,
                 auth_type: Optional[_builtins.str] = None,
                 auth_username: Optional[_builtins.str] = None,
                 base_url: Optional[_builtins.str] = None,
                 channel: Optional[_builtins.str] = None,
                 headers: Optional[Mapping[str, _builtins.str]] = None,
                 include_json_attachment: Optional[_builtins.str] = None,
                 key: Optional[_builtins.str] = None,
                 payload: Optional[Mapping[str, _builtins.str]] = None,
                 payload_string: Optional[_builtins.str] = None,
                 payload_type: Optional[_builtins.str] = None,
                 recipients: Optional[_builtins.str] = None,
                 region: Optional[_builtins.str] = None,
                 route_key: Optional[_builtins.str] = None,
                 service_key: Optional[_builtins.str] = None,
                 tags: Optional[_builtins.str] = None,
                 teams: Optional[_builtins.str] = None,
                 url: Optional[_builtins.str] = None,
                 user_id: Optional[_builtins.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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


@pulumi.output_type
class GetNotificationDestinationPropertyResult(dict):
    def __init__(__self__, *,
                 key: _builtins.str,
                 value: _builtins.str,
                 display_value: Optional[_builtins.str] = None,
                 label: Optional[_builtins.str] = None):
        """
        :param _builtins.str key: Notification property key.
        :param _builtins.str value: Notification property value.
        :param _builtins.str display_value: Notification property display key.
        :param _builtins.str label: 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)

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

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

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

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


@pulumi.output_type
class GetNotificationDestinationSecureUrlResult(dict):
    def __init__(__self__, *,
                 prefix: _builtins.str):
        pulumi.set(__self__, "prefix", prefix)

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


@pulumi.output_type
class GetTestGrokPatternTestGrokResult(dict):
    def __init__(__self__, *,
                 attributes: Sequence['outputs.GetTestGrokPatternTestGrokAttributeResult'],
                 log_line: _builtins.str,
                 matched: _builtins.bool):
        """
        :param Sequence['GetTestGrokPatternTestGrokAttributeArgs'] attributes: Nested list containing information about any attributes that were extracted.
        :param _builtins.str log_line: The log line that was tested against.
        :param _builtins.bool matched: Whether the Grok pattern matched.
        """
        pulumi.set(__self__, "attributes", attributes)
        pulumi.set(__self__, "log_line", log_line)
        pulumi.set(__self__, "matched", matched)

    @_builtins.property
    @pulumi.getter
    def attributes(self) -> Sequence['outputs.GetTestGrokPatternTestGrokAttributeResult']:
        """
        Nested list containing information about any attributes that were extracted.
        """
        return pulumi.get(self, "attributes")

    @_builtins.property
    @pulumi.getter(name="logLine")
    def log_line(self) -> _builtins.str:
        """
        The log line that was tested against.
        """
        return pulumi.get(self, "log_line")

    @_builtins.property
    @pulumi.getter
    def matched(self) -> _builtins.bool:
        """
        Whether the Grok pattern matched.
        """
        return pulumi.get(self, "matched")


@pulumi.output_type
class GetTestGrokPatternTestGrokAttributeResult(dict):
    def __init__(__self__, *,
                 name: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str name: The attribute name.
        :param _builtins.str value: A string representation of the extracted value (which might not be a String).
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The attribute name.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def value(self) -> _builtins.str:
        """
        A string representation of the extracted value (which might not be a String).
        """
        return pulumi.get(self, "value")


