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

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
from . import _utilities, _tables
from . import outputs

__all__ = [
    'AlertMutingRuleFilter',
    'DashboardChart',
    'DashboardColumn',
    'DashboardEventOverlay',
    'DashboardEventOverlaySource',
    'DashboardFilter',
    'DashboardGrid',
    'DashboardGroupDashboard',
    'DashboardGroupDashboardFilterOverride',
    'DashboardGroupDashboardVariableOverride',
    'DashboardGroupImportQualifier',
    'DashboardGroupImportQualifierFilter',
    'DashboardSelectedEventOverlay',
    'DashboardSelectedEventOverlaySource',
    'DashboardVariable',
    'DataLinkTargetExternalUrl',
    'DataLinkTargetSignalfxDashboard',
    'DataLinkTargetSplunk',
    'DetectorRule',
    'DetectorVizOption',
    'HeatmapChartColorRange',
    'HeatmapChartColorScale',
    'ListChartColorScale',
    'ListChartLegendOptionsField',
    'ListChartVizOption',
    'OrgTokenDpmLimits',
    'OrgTokenHostOrUsageLimits',
    'SingleValueChartColorScale',
    'SingleValueChartVizOption',
    'TimeChartAxisLeft',
    'TimeChartAxisLeftWatermark',
    'TimeChartAxisRight',
    'TimeChartAxisRightWatermark',
    'TimeChartEventOption',
    'TimeChartHistogramOption',
    'TimeChartLegendOptionsField',
    'TimeChartVizOption',
    'WebhookIntegrationHeader',
    'GetAwsServicesServiceResult',
    'GetAzureServicesServiceResult',
]

@pulumi.output_type
class AlertMutingRuleFilter(dict):
    def __init__(__self__, *,
                 property: str,
                 property_value: str,
                 negated: Optional[bool] = None):
        """
        :param str property: The property to filter.
        :param str property_value: The property value to filter.
        :param bool negated: Determines if this is a "not" filter. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "property_value", property_value)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter(name="propertyValue")
    def property_value(self) -> str:
        """
        The property value to filter.
        """
        return pulumi.get(self, "property_value")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        Determines if this is a "not" filter. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardChart(dict):
    def __init__(__self__, *,
                 chart_id: str,
                 column: Optional[float] = None,
                 height: Optional[float] = None,
                 row: Optional[float] = None,
                 width: Optional[float] = None):
        """
        :param str chart_id: ID of the chart to display.
        :param float column: Column number for the layout.
        :param float height: How many rows every chart should take up (greater than or equal to 1). 1 by default.
        :param float row: The row to show the chart in (zero-based); if `height > 1`, this value represents the topmost row of the chart (greater than or equal to `0`).
        :param float width: How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        pulumi.set(__self__, "chart_id", chart_id)
        if column is not None:
            pulumi.set(__self__, "column", column)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if row is not None:
            pulumi.set(__self__, "row", row)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter(name="chartId")
    def chart_id(self) -> str:
        """
        ID of the chart to display.
        """
        return pulumi.get(self, "chart_id")

    @property
    @pulumi.getter
    def column(self) -> Optional[float]:
        """
        Column number for the layout.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter
    def height(self) -> Optional[float]:
        """
        How many rows every chart should take up (greater than or equal to 1). 1 by default.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def row(self) -> Optional[float]:
        """
        The row to show the chart in (zero-based); if `height > 1`, this value represents the topmost row of the chart (greater than or equal to `0`).
        """
        return pulumi.get(self, "row")

    @property
    @pulumi.getter
    def width(self) -> Optional[float]:
        """
        How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        return pulumi.get(self, "width")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardColumn(dict):
    def __init__(__self__, *,
                 chart_ids: List[str],
                 column: Optional[float] = None,
                 height: Optional[float] = None,
                 width: Optional[float] = None):
        """
        :param List[str] chart_ids: List of IDs of the charts to display.
        :param float column: Column number for the layout.
        :param float height: How many rows every chart should take up (greater than or equal to 1). 1 by default.
        :param float width: How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        pulumi.set(__self__, "chart_ids", chart_ids)
        if column is not None:
            pulumi.set(__self__, "column", column)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter(name="chartIds")
    def chart_ids(self) -> List[str]:
        """
        List of IDs of the charts to display.
        """
        return pulumi.get(self, "chart_ids")

    @property
    @pulumi.getter
    def column(self) -> Optional[float]:
        """
        Column number for the layout.
        """
        return pulumi.get(self, "column")

    @property
    @pulumi.getter
    def height(self) -> Optional[float]:
        """
        How many rows every chart should take up (greater than or equal to 1). 1 by default.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def width(self) -> Optional[float]:
        """
        How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        return pulumi.get(self, "width")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardEventOverlay(dict):
    def __init__(__self__, *,
                 signal: str,
                 color: Optional[str] = None,
                 label: Optional[str] = None,
                 line: Optional[bool] = None,
                 sources: Optional[List['outputs.DashboardEventOverlaySource']] = None,
                 type: Optional[str] = None):
        """
        :param str signal: Search term used to choose the events shown in the overlay.
        :param str color: Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        :param str label: Text shown in the dropdown when selecting this overlay from the menu.
        :param bool line: Show a vertical line for the event. `false` by default.
        :param List['DashboardEventOverlaySourceArgs'] sources: Each element specifies a filter to use against the signal specified in the `signal`.
        :param str type: Can be set to `eventTimeSeries` (the default) to refer to externally reported events, or `detectorEvents` to refer to events from detector triggers.
        """
        pulumi.set(__self__, "signal", signal)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if line is not None:
            pulumi.set(__self__, "line", line)
        if sources is not None:
            pulumi.set(__self__, "sources", sources)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def signal(self) -> str:
        """
        Search term used to choose the events shown in the overlay.
        """
        return pulumi.get(self, "signal")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Text shown in the dropdown when selecting this overlay from the menu.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def line(self) -> Optional[bool]:
        """
        Show a vertical line for the event. `false` by default.
        """
        return pulumi.get(self, "line")

    @property
    @pulumi.getter
    def sources(self) -> Optional[List['outputs.DashboardEventOverlaySource']]:
        """
        Each element specifies a filter to use against the signal specified in the `signal`.
        """
        return pulumi.get(self, "sources")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Can be set to `eventTimeSeries` (the default) to refer to externally reported events, or `detectorEvents` to refer to events from detector triggers.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardEventOverlaySource(dict):
    def __init__(__self__, *,
                 property: str,
                 values: List[str],
                 negated: Optional[bool] = None):
        """
        :param str property: The name of a dimension to filter against.
        :param List[str] values: A list of values to be used with the `property`, they will be combined via `OR`.
        :param bool negated: If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "values", values)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter
    def values(self) -> List[str]:
        """
        A list of values to be used with the `property`, they will be combined via `OR`.
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of a dimension to filter against.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardFilter(dict):
    def __init__(__self__, *,
                 property: str,
                 values: List[str],
                 apply_if_exist: Optional[bool] = None,
                 negated: Optional[bool] = None):
        """
        :param str property: The name of a dimension to filter against.
        :param List[str] values: A list of values to be used with the `property`, they will be combined via `OR`.
        :param bool apply_if_exist: If true, this variable will also match data that doesn't have this property at all.
        :param bool negated: If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "values", values)
        if apply_if_exist is not None:
            pulumi.set(__self__, "apply_if_exist", apply_if_exist)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter
    def values(self) -> List[str]:
        """
        A list of values to be used with the `property`, they will be combined via `OR`.
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter(name="applyIfExist")
    def apply_if_exist(self) -> Optional[bool]:
        """
        If true, this variable will also match data that doesn't have this property at all.
        """
        return pulumi.get(self, "apply_if_exist")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of a dimension to filter against.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGrid(dict):
    def __init__(__self__, *,
                 chart_ids: List[str],
                 height: Optional[float] = None,
                 width: Optional[float] = None):
        """
        :param List[str] chart_ids: List of IDs of the charts to display.
        :param float height: How many rows every chart should take up (greater than or equal to 1). 1 by default.
        :param float width: How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        pulumi.set(__self__, "chart_ids", chart_ids)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter(name="chartIds")
    def chart_ids(self) -> List[str]:
        """
        List of IDs of the charts to display.
        """
        return pulumi.get(self, "chart_ids")

    @property
    @pulumi.getter
    def height(self) -> Optional[float]:
        """
        How many rows every chart should take up (greater than or equal to 1). 1 by default.
        """
        return pulumi.get(self, "height")

    @property
    @pulumi.getter
    def width(self) -> Optional[float]:
        """
        How many columns (out of a total of `12`) every chart should take up (between `1` and `12`). `12` by default.
        """
        return pulumi.get(self, "width")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGroupDashboard(dict):
    def __init__(__self__, *,
                 dashboard_id: str,
                 description_override: Optional[str] = None,
                 filter_overrides: Optional[List['outputs.DashboardGroupDashboardFilterOverride']] = None,
                 name_override: Optional[str] = None,
                 variable_overrides: Optional[List['outputs.DashboardGroupDashboardVariableOverride']] = None):
        """
        :param str dashboard_id: The dashboard id to mirror
        :param str description_override: The description that will override the original dashboards's description.
        :param List['DashboardGroupDashboardFilterOverrideArgs'] filter_overrides: The description that will override the original dashboards's description.
        :param str name_override: The name that will override the original dashboards's name.
        """
        pulumi.set(__self__, "dashboard_id", dashboard_id)
        if description_override is not None:
            pulumi.set(__self__, "description_override", description_override)
        if filter_overrides is not None:
            pulumi.set(__self__, "filter_overrides", filter_overrides)
        if name_override is not None:
            pulumi.set(__self__, "name_override", name_override)
        if variable_overrides is not None:
            pulumi.set(__self__, "variable_overrides", variable_overrides)

    @property
    @pulumi.getter(name="dashboardId")
    def dashboard_id(self) -> str:
        """
        The dashboard id to mirror
        """
        return pulumi.get(self, "dashboard_id")

    @property
    @pulumi.getter(name="descriptionOverride")
    def description_override(self) -> Optional[str]:
        """
        The description that will override the original dashboards's description.
        """
        return pulumi.get(self, "description_override")

    @property
    @pulumi.getter(name="filterOverrides")
    def filter_overrides(self) -> Optional[List['outputs.DashboardGroupDashboardFilterOverride']]:
        """
        The description that will override the original dashboards's description.
        """
        return pulumi.get(self, "filter_overrides")

    @property
    @pulumi.getter(name="nameOverride")
    def name_override(self) -> Optional[str]:
        """
        The name that will override the original dashboards's name.
        """
        return pulumi.get(self, "name_override")

    @property
    @pulumi.getter(name="variableOverrides")
    def variable_overrides(self) -> Optional[List['outputs.DashboardGroupDashboardVariableOverride']]:
        return pulumi.get(self, "variable_overrides")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGroupDashboardFilterOverride(dict):
    def __init__(__self__, *,
                 property: str,
                 values: List[str],
                 negated: Optional[bool] = None):
        """
        :param str property: A metric time series dimension or property name.
        :param List[str] values: (Optional) List of of strings (which will be treated as an OR filter on the property).
        :param bool negated: If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "values", values)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter
    def values(self) -> List[str]:
        """
        (Optional) List of of strings (which will be treated as an OR filter on the property).
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        A metric time series dimension or property name.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGroupDashboardVariableOverride(dict):
    def __init__(__self__, *,
                 property: str,
                 values: Optional[List[str]] = None,
                 values_suggesteds: Optional[List[str]] = None):
        """
        :param str property: A metric time series dimension or property name.
        :param List[str] values: (Optional) List of of strings (which will be treated as an OR filter on the property).
        :param List[str] values_suggesteds: A list of strings of suggested values for this variable; these suggestions will receive priority when values are autosuggested for this variable.
        """
        pulumi.set(__self__, "property", property)
        if values is not None:
            pulumi.set(__self__, "values", values)
        if values_suggesteds is not None:
            pulumi.set(__self__, "values_suggesteds", values_suggesteds)

    @property
    @pulumi.getter
    def values(self) -> Optional[List[str]]:
        """
        (Optional) List of of strings (which will be treated as an OR filter on the property).
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter(name="valuesSuggesteds")
    def values_suggesteds(self) -> Optional[List[str]]:
        """
        A list of strings of suggested values for this variable; these suggestions will receive priority when values are autosuggested for this variable.
        """
        return pulumi.get(self, "values_suggesteds")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        A metric time series dimension or property name.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGroupImportQualifier(dict):
    def __init__(__self__, *,
                 metric: str,
                 filters: Optional[List['outputs.DashboardGroupImportQualifierFilter']] = None):
        pulumi.set(__self__, "metric", metric)
        if filters is not None:
            pulumi.set(__self__, "filters", filters)

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

    @property
    @pulumi.getter
    def filters(self) -> Optional[List['outputs.DashboardGroupImportQualifierFilter']]:
        return pulumi.get(self, "filters")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardGroupImportQualifierFilter(dict):
    def __init__(__self__, *,
                 property: str,
                 values: List[str],
                 negated: Optional[bool] = None):
        """
        :param str property: A metric time series dimension or property name.
        :param List[str] values: (Optional) List of of strings (which will be treated as an OR filter on the property).
        :param bool negated: If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "values", values)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter
    def values(self) -> List[str]:
        """
        (Optional) List of of strings (which will be treated as an OR filter on the property).
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        A metric time series dimension or property name.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardSelectedEventOverlay(dict):
    def __init__(__self__, *,
                 signal: str,
                 sources: Optional[List['outputs.DashboardSelectedEventOverlaySource']] = None,
                 type: Optional[str] = None):
        """
        :param str signal: Search term used to choose the events shown in the overlay.
        :param List['DashboardSelectedEventOverlaySourceArgs'] sources: Each element specifies a filter to use against the signal specified in the `signal`.
        :param str type: Can be set to `eventTimeSeries` (the default) to refer to externally reported events, or `detectorEvents` to refer to events from detector triggers.
        """
        pulumi.set(__self__, "signal", signal)
        if sources is not None:
            pulumi.set(__self__, "sources", sources)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def signal(self) -> str:
        """
        Search term used to choose the events shown in the overlay.
        """
        return pulumi.get(self, "signal")

    @property
    @pulumi.getter
    def sources(self) -> Optional[List['outputs.DashboardSelectedEventOverlaySource']]:
        """
        Each element specifies a filter to use against the signal specified in the `signal`.
        """
        return pulumi.get(self, "sources")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Can be set to `eventTimeSeries` (the default) to refer to externally reported events, or `detectorEvents` to refer to events from detector triggers.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardSelectedEventOverlaySource(dict):
    def __init__(__self__, *,
                 property: str,
                 values: List[str],
                 negated: Optional[bool] = None):
        """
        :param str property: The name of a dimension to filter against.
        :param List[str] values: A list of values to be used with the `property`, they will be combined via `OR`.
        :param bool negated: If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "values", values)
        if negated is not None:
            pulumi.set(__self__, "negated", negated)

    @property
    @pulumi.getter
    def values(self) -> List[str]:
        """
        A list of values to be used with the `property`, they will be combined via `OR`.
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def negated(self) -> Optional[bool]:
        """
        If true,  only data that does not match the specified value of the specified property appear in the event overlay. Defaults to `false`.
        """
        return pulumi.get(self, "negated")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of a dimension to filter against.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DashboardVariable(dict):
    def __init__(__self__, *,
                 alias: str,
                 property: str,
                 apply_if_exist: Optional[bool] = None,
                 description: Optional[str] = None,
                 replace_only: Optional[bool] = None,
                 restricted_suggestions: Optional[bool] = None,
                 value_required: Optional[bool] = None,
                 values: Optional[List[str]] = None,
                 values_suggesteds: Optional[List[str]] = None):
        """
        :param str alias: An alias for the dashboard variable. This text will appear as the label for the dropdown field on the dashboard.
        :param str property: The name of a dimension to filter against.
        :param bool apply_if_exist: If true, this variable will also match data that doesn't have this property at all.
        :param str description: Variable description.
        :param bool replace_only: If `true`, this variable will only apply to charts that have a filter for the property.
        :param bool restricted_suggestions: If `true`, this variable may only be set to the values listed in `values_suggested` and only these values will appear in autosuggestion menus. `false` by default.
        :param bool value_required: Determines whether a value is required for this variable (and therefore whether it will be possible to view this dashboard without this filter applied). `false` by default.
        :param List[str] values: A list of values to be used with the `property`, they will be combined via `OR`.
        :param List[str] values_suggesteds: A list of strings of suggested values for this variable; these suggestions will receive priority when values are autosuggested for this variable.
        """
        pulumi.set(__self__, "alias", alias)
        pulumi.set(__self__, "property", property)
        if apply_if_exist is not None:
            pulumi.set(__self__, "apply_if_exist", apply_if_exist)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if replace_only is not None:
            pulumi.set(__self__, "replace_only", replace_only)
        if restricted_suggestions is not None:
            pulumi.set(__self__, "restricted_suggestions", restricted_suggestions)
        if value_required is not None:
            pulumi.set(__self__, "value_required", value_required)
        if values is not None:
            pulumi.set(__self__, "values", values)
        if values_suggesteds is not None:
            pulumi.set(__self__, "values_suggesteds", values_suggesteds)

    @property
    @pulumi.getter
    def alias(self) -> str:
        """
        An alias for the dashboard variable. This text will appear as the label for the dropdown field on the dashboard.
        """
        return pulumi.get(self, "alias")

    @property
    @pulumi.getter(name="applyIfExist")
    def apply_if_exist(self) -> Optional[bool]:
        """
        If true, this variable will also match data that doesn't have this property at all.
        """
        return pulumi.get(self, "apply_if_exist")

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

    @property
    @pulumi.getter(name="replaceOnly")
    def replace_only(self) -> Optional[bool]:
        """
        If `true`, this variable will only apply to charts that have a filter for the property.
        """
        return pulumi.get(self, "replace_only")

    @property
    @pulumi.getter(name="restrictedSuggestions")
    def restricted_suggestions(self) -> Optional[bool]:
        """
        If `true`, this variable may only be set to the values listed in `values_suggested` and only these values will appear in autosuggestion menus. `false` by default.
        """
        return pulumi.get(self, "restricted_suggestions")

    @property
    @pulumi.getter(name="valueRequired")
    def value_required(self) -> Optional[bool]:
        """
        Determines whether a value is required for this variable (and therefore whether it will be possible to view this dashboard without this filter applied). `false` by default.
        """
        return pulumi.get(self, "value_required")

    @property
    @pulumi.getter
    def values(self) -> Optional[List[str]]:
        """
        A list of values to be used with the `property`, they will be combined via `OR`.
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter(name="valuesSuggesteds")
    def values_suggesteds(self) -> Optional[List[str]]:
        """
        A list of strings of suggested values for this variable; these suggestions will receive priority when values are autosuggested for this variable.
        """
        return pulumi.get(self, "values_suggesteds")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of a dimension to filter against.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DataLinkTargetExternalUrl(dict):
    def __init__(__self__, *,
                 name: str,
                 url: str,
                 is_default: Optional[bool] = None,
                 minimum_time_window: Optional[str] = None,
                 property_key_mapping: Optional[Mapping[str, str]] = None,
                 time_format: Optional[str] = None):
        """
        :param str name: User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        :param str url: URL string for a Splunk instance or external system data link target. [See the supported template variables](https://developers.signalfx.com/administration/data_links_overview.html#_external_link_targets).
        :param bool is_default: Flag that designates a target as the default for a data link object. `true` by default
        :param str minimum_time_window: The [minimum time window](https://developers.signalfx.com/administration/data_links_overview.html#_minimum_time_window) for a search sent to an external site. Defaults to `6000`
        :param Mapping[str, str] property_key_mapping: Describes the relationship between SignalFx metadata keys and external system properties when the key names are different.
        :param str time_format: [Designates the format](https://developers.signalfx.com/administration/data_links_overview.html#_minimum_time_window) of `minimum_time_window` in the same data link target object. Must be one of `"ISO8601"`, `"EpochSeconds"` or `"Epoch"` (which is milliseconds). Defaults to `"ISO8601"`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "url", url)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if minimum_time_window is not None:
            pulumi.set(__self__, "minimum_time_window", minimum_time_window)
        if property_key_mapping is not None:
            pulumi.set(__self__, "property_key_mapping", property_key_mapping)
        if time_format is not None:
            pulumi.set(__self__, "time_format", time_format)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        URL string for a Splunk instance or external system data link target. [See the supported template variables](https://developers.signalfx.com/administration/data_links_overview.html#_external_link_targets).
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        """
        Flag that designates a target as the default for a data link object. `true` by default
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="minimumTimeWindow")
    def minimum_time_window(self) -> Optional[str]:
        """
        The [minimum time window](https://developers.signalfx.com/administration/data_links_overview.html#_minimum_time_window) for a search sent to an external site. Defaults to `6000`
        """
        return pulumi.get(self, "minimum_time_window")

    @property
    @pulumi.getter(name="propertyKeyMapping")
    def property_key_mapping(self) -> Optional[Mapping[str, str]]:
        """
        Describes the relationship between SignalFx metadata keys and external system properties when the key names are different.
        """
        return pulumi.get(self, "property_key_mapping")

    @property
    @pulumi.getter(name="timeFormat")
    def time_format(self) -> Optional[str]:
        """
        [Designates the format](https://developers.signalfx.com/administration/data_links_overview.html#_minimum_time_window) of `minimum_time_window` in the same data link target object. Must be one of `"ISO8601"`, `"EpochSeconds"` or `"Epoch"` (which is milliseconds). Defaults to `"ISO8601"`.
        """
        return pulumi.get(self, "time_format")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DataLinkTargetSignalfxDashboard(dict):
    def __init__(__self__, *,
                 dashboard_group_id: str,
                 dashboard_id: str,
                 name: str,
                 is_default: Optional[bool] = None):
        """
        :param str dashboard_group_id: SignalFx-assigned ID of the dashboard link target's dashboard group
        :param str dashboard_id: SignalFx-assigned ID of the dashboard link target
        :param str name: User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        :param bool is_default: Flag that designates a target as the default for a data link object. `true` by default
        """
        pulumi.set(__self__, "dashboard_group_id", dashboard_group_id)
        pulumi.set(__self__, "dashboard_id", dashboard_id)
        pulumi.set(__self__, "name", name)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)

    @property
    @pulumi.getter(name="dashboardGroupId")
    def dashboard_group_id(self) -> str:
        """
        SignalFx-assigned ID of the dashboard link target's dashboard group
        """
        return pulumi.get(self, "dashboard_group_id")

    @property
    @pulumi.getter(name="dashboardId")
    def dashboard_id(self) -> str:
        """
        SignalFx-assigned ID of the dashboard link target
        """
        return pulumi.get(self, "dashboard_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        """
        Flag that designates a target as the default for a data link object. `true` by default
        """
        return pulumi.get(self, "is_default")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DataLinkTargetSplunk(dict):
    def __init__(__self__, *,
                 name: str,
                 is_default: Optional[bool] = None,
                 property_key_mapping: Optional[Mapping[str, str]] = None):
        """
        :param str name: User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        :param bool is_default: Flag that designates a target as the default for a data link object. `true` by default
        :param Mapping[str, str] property_key_mapping: Describes the relationship between SignalFx metadata keys and external system properties when the key names are different.
        """
        pulumi.set(__self__, "name", name)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if property_key_mapping is not None:
            pulumi.set(__self__, "property_key_mapping", property_key_mapping)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        User-assigned target name. Use this value to differentiate between the link targets for a data link object.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> Optional[bool]:
        """
        Flag that designates a target as the default for a data link object. `true` by default
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="propertyKeyMapping")
    def property_key_mapping(self) -> Optional[Mapping[str, str]]:
        """
        Describes the relationship between SignalFx metadata keys and external system properties when the key names are different.
        """
        return pulumi.get(self, "property_key_mapping")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DetectorRule(dict):
    def __init__(__self__, *,
                 detect_label: str,
                 severity: str,
                 description: Optional[str] = None,
                 disabled: Optional[bool] = None,
                 notifications: Optional[List[str]] = None,
                 parameterized_body: Optional[str] = None,
                 parameterized_subject: Optional[str] = None,
                 runbook_url: Optional[str] = None,
                 tip: Optional[str] = None):
        """
        :param str detect_label: A detect label which matches a detect label within `program_text`.
        :param str severity: The severity of the rule, must be one of: `"Critical"`, `"Major"`, `"Minor"`, `"Warning"`, `"Info"`.
        :param str description: Description for the rule. Displays as the alert condition in the Alert Rules tab of the detector editor in the web UI.
        :param bool disabled: When true, notifications and events will not be generated for the detect label. `false` by default.
        :param List[str] notifications: List of strings specifying where notifications will be sent when an incident occurs. See [Create A Single Detector](https://developers.signalfx.com/detectors_reference.html#operation/Create%20Single%20Detector) for more info.
        :param str parameterized_body: Custom notification message body when an alert is triggered. See [Set Up Detectors to Trigger Alerts](https://docs.signalfx.com/en/latest/detect-alert/set-up-detectors.html#about-detectors#alert-settings) for more info.
        :param str parameterized_subject: Custom notification message subject when an alert is triggered. See [Set Up Detectors to Trigger Alerts](https://docs.signalfx.com/en/latest/detect-alert/set-up-detectors.html#about-detectors#alert-settings) for more info.
        :param str runbook_url: URL of page to consult when an alert is triggered. This can be used with custom notification messages.
        :param str tip: Plain text suggested first course of action, such as a command line to execute. This can be used with custom notification messages.
        """
        pulumi.set(__self__, "detect_label", detect_label)
        pulumi.set(__self__, "severity", severity)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if notifications is not None:
            pulumi.set(__self__, "notifications", notifications)
        if parameterized_body is not None:
            pulumi.set(__self__, "parameterized_body", parameterized_body)
        if parameterized_subject is not None:
            pulumi.set(__self__, "parameterized_subject", parameterized_subject)
        if runbook_url is not None:
            pulumi.set(__self__, "runbook_url", runbook_url)
        if tip is not None:
            pulumi.set(__self__, "tip", tip)

    @property
    @pulumi.getter(name="detectLabel")
    def detect_label(self) -> str:
        """
        A detect label which matches a detect label within `program_text`.
        """
        return pulumi.get(self, "detect_label")

    @property
    @pulumi.getter
    def severity(self) -> str:
        """
        The severity of the rule, must be one of: `"Critical"`, `"Major"`, `"Minor"`, `"Warning"`, `"Info"`.
        """
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Description for the rule. Displays as the alert condition in the Alert Rules tab of the detector editor in the web UI.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        When true, notifications and events will not be generated for the detect label. `false` by default.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter
    def notifications(self) -> Optional[List[str]]:
        """
        List of strings specifying where notifications will be sent when an incident occurs. See [Create A Single Detector](https://developers.signalfx.com/detectors_reference.html#operation/Create%20Single%20Detector) for more info.
        """
        return pulumi.get(self, "notifications")

    @property
    @pulumi.getter(name="parameterizedBody")
    def parameterized_body(self) -> Optional[str]:
        """
        Custom notification message body when an alert is triggered. See [Set Up Detectors to Trigger Alerts](https://docs.signalfx.com/en/latest/detect-alert/set-up-detectors.html#about-detectors#alert-settings) for more info.
        """
        return pulumi.get(self, "parameterized_body")

    @property
    @pulumi.getter(name="parameterizedSubject")
    def parameterized_subject(self) -> Optional[str]:
        """
        Custom notification message subject when an alert is triggered. See [Set Up Detectors to Trigger Alerts](https://docs.signalfx.com/en/latest/detect-alert/set-up-detectors.html#about-detectors#alert-settings) for more info.
        """
        return pulumi.get(self, "parameterized_subject")

    @property
    @pulumi.getter(name="runbookUrl")
    def runbook_url(self) -> Optional[str]:
        """
        URL of page to consult when an alert is triggered. This can be used with custom notification messages.
        """
        return pulumi.get(self, "runbook_url")

    @property
    @pulumi.getter
    def tip(self) -> Optional[str]:
        """
        Plain text suggested first course of action, such as a command line to execute. This can be used with custom notification messages.
        """
        return pulumi.get(self, "tip")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DetectorVizOption(dict):
    def __init__(__self__, *,
                 label: str,
                 color: Optional[str] = None,
                 display_name: Optional[str] = None,
                 value_prefix: Optional[str] = None,
                 value_suffix: Optional[str] = None,
                 value_unit: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        :param str color: Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        :param str display_name: Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        :param str value_unit: A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
               * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        pulumi.set(__self__, "label", label)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if value_prefix is not None:
            pulumi.set(__self__, "value_prefix", value_prefix)
        if value_suffix is not None:
            pulumi.set(__self__, "value_suffix", value_suffix)
        if value_unit is not None:
            pulumi.set(__self__, "value_unit", value_unit)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        return pulumi.get(self, "display_name")

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

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

    @property
    @pulumi.getter(name="valueUnit")
    def value_unit(self) -> Optional[str]:
        """
        A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
        * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        return pulumi.get(self, "value_unit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class HeatmapChartColorRange(dict):
    def __init__(__self__, *,
                 color: str,
                 max_value: Optional[float] = None,
                 min_value: Optional[float] = None):
        """
        :param str color: The color range to use. Hex values are not supported here. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param float max_value: The maximum value within the coloring range.
        :param float min_value: The minimum value within the coloring range.
        """
        pulumi.set(__self__, "color", color)
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)

    @property
    @pulumi.getter
    def color(self) -> str:
        """
        The color range to use. Hex values are not supported here. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> Optional[float]:
        """
        The maximum value within the coloring range.
        """
        return pulumi.get(self, "max_value")

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> Optional[float]:
        """
        The minimum value within the coloring range.
        """
        return pulumi.get(self, "min_value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class HeatmapChartColorScale(dict):
    def __init__(__self__, *,
                 color: str,
                 gt: Optional[float] = None,
                 gte: Optional[float] = None,
                 lt: Optional[float] = None,
                 lte: Optional[float] = None):
        """
        :param str color: The color range to use. Hex values are not supported here. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param float gt: Indicates the lower threshold non-inclusive value for this range.
        :param float gte: Indicates the lower threshold inclusive value for this range.
        :param float lt: Indicates the upper threshold non-inclusive value for this range.
        :param float lte: Indicates the upper threshold inclusive value for this range.
        """
        pulumi.set(__self__, "color", color)
        if gt is not None:
            pulumi.set(__self__, "gt", gt)
        if gte is not None:
            pulumi.set(__self__, "gte", gte)
        if lt is not None:
            pulumi.set(__self__, "lt", lt)
        if lte is not None:
            pulumi.set(__self__, "lte", lte)

    @property
    @pulumi.getter
    def color(self) -> str:
        """
        The color range to use. Hex values are not supported here. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter
    def gt(self) -> Optional[float]:
        """
        Indicates the lower threshold non-inclusive value for this range.
        """
        return pulumi.get(self, "gt")

    @property
    @pulumi.getter
    def gte(self) -> Optional[float]:
        """
        Indicates the lower threshold inclusive value for this range.
        """
        return pulumi.get(self, "gte")

    @property
    @pulumi.getter
    def lt(self) -> Optional[float]:
        """
        Indicates the upper threshold non-inclusive value for this range.
        """
        return pulumi.get(self, "lt")

    @property
    @pulumi.getter
    def lte(self) -> Optional[float]:
        """
        Indicates the upper threshold inclusive value for this range.
        """
        return pulumi.get(self, "lte")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ListChartColorScale(dict):
    def __init__(__self__, *,
                 color: str,
                 gt: Optional[float] = None,
                 gte: Optional[float] = None,
                 lt: Optional[float] = None,
                 lte: Optional[float] = None):
        """
        :param str color: The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param float gt: Indicates the lower threshold non-inclusive value for this range.
        :param float gte: Indicates the lower threshold inclusive value for this range.
        :param float lt: Indicates the upper threshold non-inculsive value for this range.
        :param float lte: Indicates the upper threshold inclusive value for this range.
        """
        pulumi.set(__self__, "color", color)
        if gt is not None:
            pulumi.set(__self__, "gt", gt)
        if gte is not None:
            pulumi.set(__self__, "gte", gte)
        if lt is not None:
            pulumi.set(__self__, "lt", lt)
        if lte is not None:
            pulumi.set(__self__, "lte", lte)

    @property
    @pulumi.getter
    def color(self) -> str:
        """
        The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter
    def gt(self) -> Optional[float]:
        """
        Indicates the lower threshold non-inclusive value for this range.
        """
        return pulumi.get(self, "gt")

    @property
    @pulumi.getter
    def gte(self) -> Optional[float]:
        """
        Indicates the lower threshold inclusive value for this range.
        """
        return pulumi.get(self, "gte")

    @property
    @pulumi.getter
    def lt(self) -> Optional[float]:
        """
        Indicates the upper threshold non-inculsive value for this range.
        """
        return pulumi.get(self, "lt")

    @property
    @pulumi.getter
    def lte(self) -> Optional[float]:
        """
        Indicates the upper threshold inclusive value for this range.
        """
        return pulumi.get(self, "lte")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ListChartLegendOptionsField(dict):
    def __init__(__self__, *,
                 property: str,
                 enabled: Optional[bool] = None):
        """
        :param str property: The name of the property to display. Note the special values of `sf_metric` (corresponding with the API's `Plot Name`) which shows the label of the time series `publish()` and `sf_originatingMetric` (corresponding with the API's `metric (sf metric)`) that shows the [name of the metric](https://developers.signalfx.com/signalflow_analytics/functions/data_function.html#table-1-parameter-definitions) for the time series being displayed.
        :param bool enabled: True or False depending on if you want the property to be shown or hidden.
        """
        pulumi.set(__self__, "property", property)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        True or False depending on if you want the property to be shown or hidden.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of the property to display. Note the special values of `sf_metric` (corresponding with the API's `Plot Name`) which shows the label of the time series `publish()` and `sf_originatingMetric` (corresponding with the API's `metric (sf metric)`) that shows the [name of the metric](https://developers.signalfx.com/signalflow_analytics/functions/data_function.html#table-1-parameter-definitions) for the time series being displayed.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ListChartVizOption(dict):
    def __init__(__self__, *,
                 label: str,
                 color: Optional[str] = None,
                 display_name: Optional[str] = None,
                 value_prefix: Optional[str] = None,
                 value_suffix: Optional[str] = None,
                 value_unit: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        :param str color: The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param str display_name: Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        :param str value_unit: A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
               * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        pulumi.set(__self__, "label", label)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if value_prefix is not None:
            pulumi.set(__self__, "value_prefix", value_prefix)
        if value_suffix is not None:
            pulumi.set(__self__, "value_suffix", value_suffix)
        if value_unit is not None:
            pulumi.set(__self__, "value_unit", value_unit)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        return pulumi.get(self, "display_name")

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

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

    @property
    @pulumi.getter(name="valueUnit")
    def value_unit(self) -> Optional[str]:
        """
        A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
        * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        return pulumi.get(self, "value_unit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class OrgTokenDpmLimits(dict):
    def __init__(__self__, *,
                 dpm_limit: float,
                 dpm_notification_threshold: Optional[float] = None):
        """
        :param float dpm_limit: The datapoints per minute (dpm) limit for this token. If you exceed this limit, SignalFx sends out an alert.
        :param float dpm_notification_threshold: DPM level at which SignalFx sends the notification for this token. If you don't specify a notification, SignalFx sends the generic notification.
        """
        pulumi.set(__self__, "dpm_limit", dpm_limit)
        if dpm_notification_threshold is not None:
            pulumi.set(__self__, "dpm_notification_threshold", dpm_notification_threshold)

    @property
    @pulumi.getter(name="dpmLimit")
    def dpm_limit(self) -> float:
        """
        The datapoints per minute (dpm) limit for this token. If you exceed this limit, SignalFx sends out an alert.
        """
        return pulumi.get(self, "dpm_limit")

    @property
    @pulumi.getter(name="dpmNotificationThreshold")
    def dpm_notification_threshold(self) -> Optional[float]:
        """
        DPM level at which SignalFx sends the notification for this token. If you don't specify a notification, SignalFx sends the generic notification.
        """
        return pulumi.get(self, "dpm_notification_threshold")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class OrgTokenHostOrUsageLimits(dict):
    def __init__(__self__, *,
                 container_limit: Optional[float] = None,
                 container_notification_threshold: Optional[float] = None,
                 custom_metrics_limit: Optional[float] = None,
                 custom_metrics_notification_threshold: Optional[float] = None,
                 high_res_metrics_limit: Optional[float] = None,
                 high_res_metrics_notification_threshold: Optional[float] = None,
                 host_limit: Optional[float] = None,
                 host_notification_threshold: Optional[float] = None):
        """
        :param float container_limit: Max number of Docker containers that can use this token
        :param float container_notification_threshold: Notification threshold for Docker containers
        :param float custom_metrics_limit: Max number of custom metrics that can be sent with this token
        :param float custom_metrics_notification_threshold: Notification threshold for custom metrics
        :param float high_res_metrics_limit: Max number of hi-res metrics that can be sent with this toke
        :param float high_res_metrics_notification_threshold: Notification threshold for hi-res metrics
        :param float host_limit: Max number of hosts that can use this token
        :param float host_notification_threshold: Notification threshold for hosts
        """
        if container_limit is not None:
            pulumi.set(__self__, "container_limit", container_limit)
        if container_notification_threshold is not None:
            pulumi.set(__self__, "container_notification_threshold", container_notification_threshold)
        if custom_metrics_limit is not None:
            pulumi.set(__self__, "custom_metrics_limit", custom_metrics_limit)
        if custom_metrics_notification_threshold is not None:
            pulumi.set(__self__, "custom_metrics_notification_threshold", custom_metrics_notification_threshold)
        if high_res_metrics_limit is not None:
            pulumi.set(__self__, "high_res_metrics_limit", high_res_metrics_limit)
        if high_res_metrics_notification_threshold is not None:
            pulumi.set(__self__, "high_res_metrics_notification_threshold", high_res_metrics_notification_threshold)
        if host_limit is not None:
            pulumi.set(__self__, "host_limit", host_limit)
        if host_notification_threshold is not None:
            pulumi.set(__self__, "host_notification_threshold", host_notification_threshold)

    @property
    @pulumi.getter(name="containerLimit")
    def container_limit(self) -> Optional[float]:
        """
        Max number of Docker containers that can use this token
        """
        return pulumi.get(self, "container_limit")

    @property
    @pulumi.getter(name="containerNotificationThreshold")
    def container_notification_threshold(self) -> Optional[float]:
        """
        Notification threshold for Docker containers
        """
        return pulumi.get(self, "container_notification_threshold")

    @property
    @pulumi.getter(name="customMetricsLimit")
    def custom_metrics_limit(self) -> Optional[float]:
        """
        Max number of custom metrics that can be sent with this token
        """
        return pulumi.get(self, "custom_metrics_limit")

    @property
    @pulumi.getter(name="customMetricsNotificationThreshold")
    def custom_metrics_notification_threshold(self) -> Optional[float]:
        """
        Notification threshold for custom metrics
        """
        return pulumi.get(self, "custom_metrics_notification_threshold")

    @property
    @pulumi.getter(name="highResMetricsLimit")
    def high_res_metrics_limit(self) -> Optional[float]:
        """
        Max number of hi-res metrics that can be sent with this toke
        """
        return pulumi.get(self, "high_res_metrics_limit")

    @property
    @pulumi.getter(name="highResMetricsNotificationThreshold")
    def high_res_metrics_notification_threshold(self) -> Optional[float]:
        """
        Notification threshold for hi-res metrics
        """
        return pulumi.get(self, "high_res_metrics_notification_threshold")

    @property
    @pulumi.getter(name="hostLimit")
    def host_limit(self) -> Optional[float]:
        """
        Max number of hosts that can use this token
        """
        return pulumi.get(self, "host_limit")

    @property
    @pulumi.getter(name="hostNotificationThreshold")
    def host_notification_threshold(self) -> Optional[float]:
        """
        Notification threshold for hosts
        """
        return pulumi.get(self, "host_notification_threshold")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SingleValueChartColorScale(dict):
    def __init__(__self__, *,
                 color: str,
                 gt: Optional[float] = None,
                 gte: Optional[float] = None,
                 lt: Optional[float] = None,
                 lte: Optional[float] = None):
        """
        :param str color: The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param float gt: Indicates the lower threshold non-inclusive value for this range.
        :param float gte: Indicates the lower threshold inclusive value for this range.
        :param float lt: Indicates the upper threshold non-inculsive value for this range.
        :param float lte: Indicates the upper threshold inclusive value for this range.
        """
        pulumi.set(__self__, "color", color)
        if gt is not None:
            pulumi.set(__self__, "gt", gt)
        if gte is not None:
            pulumi.set(__self__, "gte", gte)
        if lt is not None:
            pulumi.set(__self__, "lt", lt)
        if lte is not None:
            pulumi.set(__self__, "lte", lte)

    @property
    @pulumi.getter
    def color(self) -> str:
        """
        The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter
    def gt(self) -> Optional[float]:
        """
        Indicates the lower threshold non-inclusive value for this range.
        """
        return pulumi.get(self, "gt")

    @property
    @pulumi.getter
    def gte(self) -> Optional[float]:
        """
        Indicates the lower threshold inclusive value for this range.
        """
        return pulumi.get(self, "gte")

    @property
    @pulumi.getter
    def lt(self) -> Optional[float]:
        """
        Indicates the upper threshold non-inculsive value for this range.
        """
        return pulumi.get(self, "lt")

    @property
    @pulumi.getter
    def lte(self) -> Optional[float]:
        """
        Indicates the upper threshold inclusive value for this range.
        """
        return pulumi.get(self, "lte")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SingleValueChartVizOption(dict):
    def __init__(__self__, *,
                 label: str,
                 color: Optional[str] = None,
                 display_name: Optional[str] = None,
                 value_prefix: Optional[str] = None,
                 value_suffix: Optional[str] = None,
                 value_unit: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        :param str color: The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        :param str display_name: Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        :param str value_unit: A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
               * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        pulumi.set(__self__, "label", label)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if value_prefix is not None:
            pulumi.set(__self__, "value_prefix", value_prefix)
        if value_suffix is not None:
            pulumi.set(__self__, "value_suffix", value_suffix)
        if value_unit is not None:
            pulumi.set(__self__, "value_unit", value_unit)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label used in the publish statement that displays the plot (metric time series data) you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        The color to use. Must be one of gray, blue, light_blue, navy, dark_orange, orange, dark_yellow, magenta, cerise, pink, violet, purple, gray_blue, dark_green, green, aquamarine, red, yellow, vivid_yellow, light_green, or lime_green.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        return pulumi.get(self, "display_name")

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

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

    @property
    @pulumi.getter(name="valueUnit")
    def value_unit(self) -> Optional[str]:
        """
        A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
        * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        return pulumi.get(self, "value_unit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartAxisLeft(dict):
    def __init__(__self__, *,
                 high_watermark: Optional[float] = None,
                 high_watermark_label: Optional[str] = None,
                 label: Optional[str] = None,
                 low_watermark: Optional[float] = None,
                 low_watermark_label: Optional[str] = None,
                 max_value: Optional[float] = None,
                 min_value: Optional[float] = None,
                 watermarks: Optional[List['outputs.TimeChartAxisLeftWatermark']] = None):
        """
        :param float high_watermark: A line to draw as a high watermark.
        :param str high_watermark_label: A label to attach to the high watermark line.
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        :param float low_watermark: A line to draw as a low watermark.
        :param str low_watermark_label: A label to attach to the low watermark line.
        :param float max_value: The maximum value for the right axis.
        :param float min_value: The minimum value for the right axis.
        """
        if high_watermark is not None:
            pulumi.set(__self__, "high_watermark", high_watermark)
        if high_watermark_label is not None:
            pulumi.set(__self__, "high_watermark_label", high_watermark_label)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if low_watermark is not None:
            pulumi.set(__self__, "low_watermark", low_watermark)
        if low_watermark_label is not None:
            pulumi.set(__self__, "low_watermark_label", low_watermark_label)
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)
        if watermarks is not None:
            pulumi.set(__self__, "watermarks", watermarks)

    @property
    @pulumi.getter(name="highWatermark")
    def high_watermark(self) -> Optional[float]:
        """
        A line to draw as a high watermark.
        """
        return pulumi.get(self, "high_watermark")

    @property
    @pulumi.getter(name="highWatermarkLabel")
    def high_watermark_label(self) -> Optional[str]:
        """
        A label to attach to the high watermark line.
        """
        return pulumi.get(self, "high_watermark_label")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="lowWatermark")
    def low_watermark(self) -> Optional[float]:
        """
        A line to draw as a low watermark.
        """
        return pulumi.get(self, "low_watermark")

    @property
    @pulumi.getter(name="lowWatermarkLabel")
    def low_watermark_label(self) -> Optional[str]:
        """
        A label to attach to the low watermark line.
        """
        return pulumi.get(self, "low_watermark_label")

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> Optional[float]:
        """
        The maximum value for the right axis.
        """
        return pulumi.get(self, "max_value")

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> Optional[float]:
        """
        The minimum value for the right axis.
        """
        return pulumi.get(self, "min_value")

    @property
    @pulumi.getter
    def watermarks(self) -> Optional[List['outputs.TimeChartAxisLeftWatermark']]:
        return pulumi.get(self, "watermarks")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartAxisLeftWatermark(dict):
    def __init__(__self__, *,
                 value: float,
                 label: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        """
        pulumi.set(__self__, "value", value)
        if label is not None:
            pulumi.set(__self__, "label", label)

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

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartAxisRight(dict):
    def __init__(__self__, *,
                 high_watermark: Optional[float] = None,
                 high_watermark_label: Optional[str] = None,
                 label: Optional[str] = None,
                 low_watermark: Optional[float] = None,
                 low_watermark_label: Optional[str] = None,
                 max_value: Optional[float] = None,
                 min_value: Optional[float] = None,
                 watermarks: Optional[List['outputs.TimeChartAxisRightWatermark']] = None):
        """
        :param float high_watermark: A line to draw as a high watermark.
        :param str high_watermark_label: A label to attach to the high watermark line.
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        :param float low_watermark: A line to draw as a low watermark.
        :param str low_watermark_label: A label to attach to the low watermark line.
        :param float max_value: The maximum value for the right axis.
        :param float min_value: The minimum value for the right axis.
        """
        if high_watermark is not None:
            pulumi.set(__self__, "high_watermark", high_watermark)
        if high_watermark_label is not None:
            pulumi.set(__self__, "high_watermark_label", high_watermark_label)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if low_watermark is not None:
            pulumi.set(__self__, "low_watermark", low_watermark)
        if low_watermark_label is not None:
            pulumi.set(__self__, "low_watermark_label", low_watermark_label)
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)
        if watermarks is not None:
            pulumi.set(__self__, "watermarks", watermarks)

    @property
    @pulumi.getter(name="highWatermark")
    def high_watermark(self) -> Optional[float]:
        """
        A line to draw as a high watermark.
        """
        return pulumi.get(self, "high_watermark")

    @property
    @pulumi.getter(name="highWatermarkLabel")
    def high_watermark_label(self) -> Optional[str]:
        """
        A label to attach to the high watermark line.
        """
        return pulumi.get(self, "high_watermark_label")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="lowWatermark")
    def low_watermark(self) -> Optional[float]:
        """
        A line to draw as a low watermark.
        """
        return pulumi.get(self, "low_watermark")

    @property
    @pulumi.getter(name="lowWatermarkLabel")
    def low_watermark_label(self) -> Optional[str]:
        """
        A label to attach to the low watermark line.
        """
        return pulumi.get(self, "low_watermark_label")

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> Optional[float]:
        """
        The maximum value for the right axis.
        """
        return pulumi.get(self, "max_value")

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> Optional[float]:
        """
        The minimum value for the right axis.
        """
        return pulumi.get(self, "min_value")

    @property
    @pulumi.getter
    def watermarks(self) -> Optional[List['outputs.TimeChartAxisRightWatermark']]:
        return pulumi.get(self, "watermarks")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartAxisRightWatermark(dict):
    def __init__(__self__, *,
                 value: float,
                 label: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        """
        pulumi.set(__self__, "value", value)
        if label is not None:
            pulumi.set(__self__, "label", label)

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

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartEventOption(dict):
    def __init__(__self__, *,
                 label: str,
                 color: Optional[str] = None,
                 display_name: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        :param str color: Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        :param str display_name: Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        pulumi.set(__self__, "label", label)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        return pulumi.get(self, "display_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartHistogramOption(dict):
    def __init__(__self__, *,
                 color_theme: Optional[str] = None):
        """
        :param str color_theme: Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine, red, gold, greenyellow, chartreuse, jade
        """
        if color_theme is not None:
            pulumi.set(__self__, "color_theme", color_theme)

    @property
    @pulumi.getter(name="colorTheme")
    def color_theme(self) -> Optional[str]:
        """
        Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine, red, gold, greenyellow, chartreuse, jade
        """
        return pulumi.get(self, "color_theme")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartLegendOptionsField(dict):
    def __init__(__self__, *,
                 property: str,
                 enabled: Optional[bool] = None):
        """
        :param str property: The name of the property to display. Note the special values of `plot_label` (corresponding with the API's `sf_metric`) which shows the label of the time series `publish()` and `metric` (corresponding with the API's `sf_originatingMetric`) that shows the name of the metric for the time series being displayed.
        :param bool enabled: True or False depending on if you want the property to be shown or hidden.
        """
        pulumi.set(__self__, "property", property)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        True or False depending on if you want the property to be shown or hidden.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def property(self) -> str:
        """
        The name of the property to display. Note the special values of `plot_label` (corresponding with the API's `sf_metric`) which shows the label of the time series `publish()` and `metric` (corresponding with the API's `sf_originatingMetric`) that shows the name of the metric for the time series being displayed.
        """
        return pulumi.get(self, "property")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TimeChartVizOption(dict):
    def __init__(__self__, *,
                 label: str,
                 axis: Optional[str] = None,
                 color: Optional[str] = None,
                 display_name: Optional[str] = None,
                 plot_type: Optional[str] = None,
                 value_prefix: Optional[str] = None,
                 value_suffix: Optional[str] = None,
                 value_unit: Optional[str] = None):
        """
        :param str label: Label used in the publish statement that displays the event query you want to customize.
        :param str axis: Y-axis associated with values for this plot. Must be either `right` or `left`.
        :param str color: Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        :param str display_name: Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        :param str plot_type: The visualization style to use. Must be `"LineChart"`, `"AreaChart"`, `"ColumnChart"`, or `"Histogram"`. Chart level `plot_type` by default.
        :param str value_unit: A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
               * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        pulumi.set(__self__, "label", label)
        if axis is not None:
            pulumi.set(__self__, "axis", axis)
        if color is not None:
            pulumi.set(__self__, "color", color)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if plot_type is not None:
            pulumi.set(__self__, "plot_type", plot_type)
        if value_prefix is not None:
            pulumi.set(__self__, "value_prefix", value_prefix)
        if value_suffix is not None:
            pulumi.set(__self__, "value_suffix", value_suffix)
        if value_unit is not None:
            pulumi.set(__self__, "value_unit", value_unit)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label used in the publish statement that displays the event query you want to customize.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def axis(self) -> Optional[str]:
        """
        Y-axis associated with values for this plot. Must be either `right` or `left`.
        """
        return pulumi.get(self, "axis")

    @property
    @pulumi.getter
    def color(self) -> Optional[str]:
        """
        Color to use : gray, blue, azure, navy, brown, orange, yellow, iris, magenta, pink, purple, violet, lilac, emerald, green, aquamarine.
        """
        return pulumi.get(self, "color")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        """
        Specifies an alternate value for the Plot Name column of the Data Table associated with the chart.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="plotType")
    def plot_type(self) -> Optional[str]:
        """
        The visualization style to use. Must be `"LineChart"`, `"AreaChart"`, `"ColumnChart"`, or `"Histogram"`. Chart level `plot_type` by default.
        """
        return pulumi.get(self, "plot_type")

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

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

    @property
    @pulumi.getter(name="valueUnit")
    def value_unit(self) -> Optional[str]:
        """
        A unit to attach to this plot. Units support automatic scaling (eg thousands of bytes will be displayed as kilobytes). Values values are `Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, Byte, Kibibyte, Mebibyte, Gigibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day, Week`.
        * `value_prefix`, `value_suffix` - (Optional) Arbitrary prefix/suffix to display with the value of this plot.
        """
        return pulumi.get(self, "value_unit")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class WebhookIntegrationHeader(dict):
    def __init__(__self__, *,
                 header_key: str,
                 header_value: str):
        """
        :param str header_key: The key of the header to send
        :param str header_value: The value of the header to send
        """
        pulumi.set(__self__, "header_key", header_key)
        pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerKey")
    def header_key(self) -> str:
        """
        The key of the header to send
        """
        return pulumi.get(self, "header_key")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        The value of the header to send
        """
        return pulumi.get(self, "header_value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class GetAwsServicesServiceResult(dict):
    def __init__(__self__, *,
                 name: str):
        pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class GetAzureServicesServiceResult(dict):
    def __init__(__self__, *,
                 name: str):
        pulumi.set(__self__, "name", name)

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


