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

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

__all__ = [
    'APIKeyDnsRecordsAllowArgs',
    'APIKeyDnsRecordsAllowArgsDict',
    'APIKeyDnsRecordsDenyArgs',
    'APIKeyDnsRecordsDenyArgsDict',
    'AlertDataArgs',
    'AlertDataArgsDict',
    'ApplicationDefaultConfigArgs',
    'ApplicationDefaultConfigArgsDict',
    'DatasetDatatypeArgs',
    'DatasetDatatypeArgsDict',
    'DatasetRepeatArgs',
    'DatasetRepeatArgsDict',
    'DatasetReportArgs',
    'DatasetReportArgsDict',
    'DatasetTimeframeArgs',
    'DatasetTimeframeArgsDict',
    'MonitoringJobRuleArgs',
    'MonitoringJobRuleArgsDict',
    'NotifyListNotificationArgs',
    'NotifyListNotificationArgsDict',
    'PulsarJobBlendMetricWeightsArgs',
    'PulsarJobBlendMetricWeightsArgsDict',
    'PulsarJobConfigArgs',
    'PulsarJobConfigArgsDict',
    'PulsarJobWeightArgs',
    'PulsarJobWeightArgsDict',
    'RecordAnswerArgs',
    'RecordAnswerArgsDict',
    'RecordFilterArgs',
    'RecordFilterArgsDict',
    'RecordRegionArgs',
    'RecordRegionArgsDict',
    'TeamDnsRecordsAllowArgs',
    'TeamDnsRecordsAllowArgsDict',
    'TeamDnsRecordsDenyArgs',
    'TeamDnsRecordsDenyArgsDict',
    'TeamIpWhitelistArgs',
    'TeamIpWhitelistArgsDict',
    'UserDnsRecordsAllowArgs',
    'UserDnsRecordsAllowArgsDict',
    'UserDnsRecordsDenyArgs',
    'UserDnsRecordsDenyArgsDict',
    'ZoneSecondaryArgs',
    'ZoneSecondaryArgsDict',
    'GetMonitoringRegionsRegionArgs',
    'GetMonitoringRegionsRegionArgsDict',
]

class APIKeyDnsRecordsAllowArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class APIKeyDnsRecordsAllowArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class APIKeyDnsRecordsDenyArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class APIKeyDnsRecordsDenyArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class AlertDataArgsDict(TypedDict):
    alert_at_percent: NotRequired[pulumi.Input[_builtins.int]]
    """
    required by the account/usage alerts, with a value between 1 and 100
    """

@pulumi.input_type
class AlertDataArgs:
    def __init__(__self__, *,
                 alert_at_percent: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] alert_at_percent: required by the account/usage alerts, with a value between 1 and 100
        """
        if alert_at_percent is not None:
            pulumi.set(__self__, "alert_at_percent", alert_at_percent)

    @_builtins.property
    @pulumi.getter(name="alertAtPercent")
    def alert_at_percent(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        required by the account/usage alerts, with a value between 1 and 100
        """
        return pulumi.get(self, "alert_at_percent")

    @alert_at_percent.setter
    def alert_at_percent(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "alert_at_percent", value)


class ApplicationDefaultConfigArgsDict(TypedDict):
    http: pulumi.Input[_builtins.bool]
    """
    Indicates whether or not to use HTTP in measurements.
    """
    https: NotRequired[pulumi.Input[_builtins.bool]]
    """
    Indicates whether or not to use HTTPS in measurements.
    """
    job_timeout_millis: NotRequired[pulumi.Input[_builtins.int]]
    """
    Maximum timeout per job
    0, the primary NSONE Global Network. Normally, you should not have to worry about this.
    """
    request_timeout_millis: NotRequired[pulumi.Input[_builtins.int]]
    """
    Maximum timeout per request.
    """
    static_values: NotRequired[pulumi.Input[_builtins.bool]]
    """
    Indicates whether or not to skip aggregation for this job's measurements
    """
    use_xhr: NotRequired[pulumi.Input[_builtins.bool]]
    """
    Whether to use XMLHttpRequest (XHR) when taking measurements.
    """

@pulumi.input_type
class ApplicationDefaultConfigArgs:
    def __init__(__self__, *,
                 http: pulumi.Input[_builtins.bool],
                 https: Optional[pulumi.Input[_builtins.bool]] = None,
                 job_timeout_millis: Optional[pulumi.Input[_builtins.int]] = None,
                 request_timeout_millis: Optional[pulumi.Input[_builtins.int]] = None,
                 static_values: Optional[pulumi.Input[_builtins.bool]] = None,
                 use_xhr: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] http: Indicates whether or not to use HTTP in measurements.
        :param pulumi.Input[_builtins.bool] https: Indicates whether or not to use HTTPS in measurements.
        :param pulumi.Input[_builtins.int] job_timeout_millis: Maximum timeout per job
               0, the primary NSONE Global Network. Normally, you should not have to worry about this.
        :param pulumi.Input[_builtins.int] request_timeout_millis: Maximum timeout per request.
        :param pulumi.Input[_builtins.bool] static_values: Indicates whether or not to skip aggregation for this job's measurements
        :param pulumi.Input[_builtins.bool] use_xhr: Whether to use XMLHttpRequest (XHR) when taking measurements.
        """
        pulumi.set(__self__, "http", http)
        if https is not None:
            pulumi.set(__self__, "https", https)
        if job_timeout_millis is not None:
            pulumi.set(__self__, "job_timeout_millis", job_timeout_millis)
        if request_timeout_millis is not None:
            pulumi.set(__self__, "request_timeout_millis", request_timeout_millis)
        if static_values is not None:
            pulumi.set(__self__, "static_values", static_values)
        if use_xhr is not None:
            pulumi.set(__self__, "use_xhr", use_xhr)

    @_builtins.property
    @pulumi.getter
    def http(self) -> pulumi.Input[_builtins.bool]:
        """
        Indicates whether or not to use HTTP in measurements.
        """
        return pulumi.get(self, "http")

    @http.setter
    def http(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "http", value)

    @_builtins.property
    @pulumi.getter
    def https(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Indicates whether or not to use HTTPS in measurements.
        """
        return pulumi.get(self, "https")

    @https.setter
    def https(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "https", value)

    @_builtins.property
    @pulumi.getter(name="jobTimeoutMillis")
    def job_timeout_millis(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum timeout per job
        0, the primary NSONE Global Network. Normally, you should not have to worry about this.
        """
        return pulumi.get(self, "job_timeout_millis")

    @job_timeout_millis.setter
    def job_timeout_millis(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "job_timeout_millis", value)

    @_builtins.property
    @pulumi.getter(name="requestTimeoutMillis")
    def request_timeout_millis(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum timeout per request.
        """
        return pulumi.get(self, "request_timeout_millis")

    @request_timeout_millis.setter
    def request_timeout_millis(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "request_timeout_millis", value)

    @_builtins.property
    @pulumi.getter(name="staticValues")
    def static_values(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Indicates whether or not to skip aggregation for this job's measurements
        """
        return pulumi.get(self, "static_values")

    @static_values.setter
    def static_values(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_values", value)

    @_builtins.property
    @pulumi.getter(name="useXhr")
    def use_xhr(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to use XMLHttpRequest (XHR) when taking measurements.
        """
        return pulumi.get(self, "use_xhr")

    @use_xhr.setter
    def use_xhr(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "use_xhr", value)


class DatasetDatatypeArgsDict(TypedDict):
    data: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
    scope: pulumi.Input[_builtins.str]
    type: pulumi.Input[_builtins.str]

@pulumi.input_type
class DatasetDatatypeArgs:
    def __init__(__self__, *,
                 data: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]],
                 scope: pulumi.Input[_builtins.str],
                 type: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "type", type)

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

    @data.setter
    def data(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
        pulumi.set(self, "data", value)

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

    @scope.setter
    def scope(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "scope", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)


class DatasetRepeatArgsDict(TypedDict):
    end_after_n: pulumi.Input[_builtins.int]
    repeats_every: pulumi.Input[_builtins.str]
    start: pulumi.Input[_builtins.int]

@pulumi.input_type
class DatasetRepeatArgs:
    def __init__(__self__, *,
                 end_after_n: pulumi.Input[_builtins.int],
                 repeats_every: pulumi.Input[_builtins.str],
                 start: pulumi.Input[_builtins.int]):
        pulumi.set(__self__, "end_after_n", end_after_n)
        pulumi.set(__self__, "repeats_every", repeats_every)
        pulumi.set(__self__, "start", start)

    @_builtins.property
    @pulumi.getter(name="endAfterN")
    def end_after_n(self) -> pulumi.Input[_builtins.int]:
        return pulumi.get(self, "end_after_n")

    @end_after_n.setter
    def end_after_n(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "end_after_n", value)

    @_builtins.property
    @pulumi.getter(name="repeatsEvery")
    def repeats_every(self) -> pulumi.Input[_builtins.str]:
        return pulumi.get(self, "repeats_every")

    @repeats_every.setter
    def repeats_every(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "repeats_every", value)

    @_builtins.property
    @pulumi.getter
    def start(self) -> pulumi.Input[_builtins.int]:
        return pulumi.get(self, "start")

    @start.setter
    def start(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "start", value)


class DatasetReportArgsDict(TypedDict):
    created_at: NotRequired[pulumi.Input[_builtins.int]]
    end: NotRequired[pulumi.Input[_builtins.int]]
    id: NotRequired[pulumi.Input[_builtins.str]]
    start: NotRequired[pulumi.Input[_builtins.int]]
    status: NotRequired[pulumi.Input[_builtins.str]]

@pulumi.input_type
class DatasetReportArgs:
    def __init__(__self__, *,
                 created_at: Optional[pulumi.Input[_builtins.int]] = None,
                 end: Optional[pulumi.Input[_builtins.int]] = None,
                 id: Optional[pulumi.Input[_builtins.str]] = None,
                 start: Optional[pulumi.Input[_builtins.int]] = None,
                 status: Optional[pulumi.Input[_builtins.str]] = None):
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if start is not None:
            pulumi.set(__self__, "start", start)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[pulumi.Input[_builtins.int]]:
        return pulumi.get(self, "created_at")

    @created_at.setter
    def created_at(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "created_at", value)

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

    @end.setter
    def end(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "end", value)

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

    @id.setter
    def id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "id", value)

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

    @start.setter
    def start(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "start", value)

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

    @status.setter
    def status(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "status", value)


class DatasetTimeframeArgsDict(TypedDict):
    aggregation: pulumi.Input[_builtins.str]
    cycles: NotRequired[pulumi.Input[_builtins.int]]
    from_: NotRequired[pulumi.Input[_builtins.int]]
    to: NotRequired[pulumi.Input[_builtins.int]]

@pulumi.input_type
class DatasetTimeframeArgs:
    def __init__(__self__, *,
                 aggregation: pulumi.Input[_builtins.str],
                 cycles: Optional[pulumi.Input[_builtins.int]] = None,
                 from_: Optional[pulumi.Input[_builtins.int]] = None,
                 to: Optional[pulumi.Input[_builtins.int]] = None):
        pulumi.set(__self__, "aggregation", aggregation)
        if cycles is not None:
            pulumi.set(__self__, "cycles", cycles)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if to is not None:
            pulumi.set(__self__, "to", to)

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

    @aggregation.setter
    def aggregation(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "aggregation", value)

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

    @cycles.setter
    def cycles(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "cycles", value)

    @_builtins.property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[pulumi.Input[_builtins.int]]:
        return pulumi.get(self, "from_")

    @from_.setter
    def from_(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "from_", value)

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

    @to.setter
    def to(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "to", value)


class MonitoringJobRuleArgsDict(TypedDict):
    comparison: pulumi.Input[_builtins.str]
    key: pulumi.Input[_builtins.str]
    value: pulumi.Input[_builtins.str]

@pulumi.input_type
class MonitoringJobRuleArgs:
    def __init__(__self__, *,
                 comparison: pulumi.Input[_builtins.str],
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "comparison", comparison)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @comparison.setter
    def comparison(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "comparison", value)

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

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


class NotifyListNotificationArgsDict(TypedDict):
    config: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
    """
    Configuration details for the given notifier type.
    """
    type: pulumi.Input[_builtins.str]
    """
    The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
    """

@pulumi.input_type
class NotifyListNotificationArgs:
    def __init__(__self__, *,
                 config: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]],
                 type: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] config: Configuration details for the given notifier type.
        :param pulumi.Input[_builtins.str] type: The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
        """
        pulumi.set(__self__, "config", config)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter
    def config(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
        """
        Configuration details for the given notifier type.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
        pulumi.set(self, "config", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> pulumi.Input[_builtins.str]:
        """
        The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)


class PulsarJobBlendMetricWeightsArgsDict(TypedDict):
    timestamp: pulumi.Input[_builtins.int]

@pulumi.input_type
class PulsarJobBlendMetricWeightsArgs:
    def __init__(__self__, *,
                 timestamp: pulumi.Input[_builtins.int]):
        pulumi.set(__self__, "timestamp", timestamp)

    @_builtins.property
    @pulumi.getter
    def timestamp(self) -> pulumi.Input[_builtins.int]:
        return pulumi.get(self, "timestamp")

    @timestamp.setter
    def timestamp(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "timestamp", value)


class PulsarJobConfigArgsDict(TypedDict):
    host: NotRequired[pulumi.Input[_builtins.str]]
    http: NotRequired[pulumi.Input[_builtins.bool]]
    https: NotRequired[pulumi.Input[_builtins.bool]]
    job_timeout_millis: NotRequired[pulumi.Input[_builtins.int]]
    request_timeout_millis: NotRequired[pulumi.Input[_builtins.int]]
    static_values: NotRequired[pulumi.Input[_builtins.bool]]
    url_path: NotRequired[pulumi.Input[_builtins.str]]
    use_xhr: NotRequired[pulumi.Input[_builtins.bool]]

@pulumi.input_type
class PulsarJobConfigArgs:
    def __init__(__self__, *,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 http: Optional[pulumi.Input[_builtins.bool]] = None,
                 https: Optional[pulumi.Input[_builtins.bool]] = None,
                 job_timeout_millis: Optional[pulumi.Input[_builtins.int]] = None,
                 request_timeout_millis: Optional[pulumi.Input[_builtins.int]] = None,
                 static_values: Optional[pulumi.Input[_builtins.bool]] = None,
                 url_path: Optional[pulumi.Input[_builtins.str]] = None,
                 use_xhr: Optional[pulumi.Input[_builtins.bool]] = None):
        if host is not None:
            pulumi.set(__self__, "host", host)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if https is not None:
            pulumi.set(__self__, "https", https)
        if job_timeout_millis is not None:
            pulumi.set(__self__, "job_timeout_millis", job_timeout_millis)
        if request_timeout_millis is not None:
            pulumi.set(__self__, "request_timeout_millis", request_timeout_millis)
        if static_values is not None:
            pulumi.set(__self__, "static_values", static_values)
        if url_path is not None:
            pulumi.set(__self__, "url_path", url_path)
        if use_xhr is not None:
            pulumi.set(__self__, "use_xhr", use_xhr)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

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

    @http.setter
    def http(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "http", value)

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

    @https.setter
    def https(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "https", value)

    @_builtins.property
    @pulumi.getter(name="jobTimeoutMillis")
    def job_timeout_millis(self) -> Optional[pulumi.Input[_builtins.int]]:
        return pulumi.get(self, "job_timeout_millis")

    @job_timeout_millis.setter
    def job_timeout_millis(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "job_timeout_millis", value)

    @_builtins.property
    @pulumi.getter(name="requestTimeoutMillis")
    def request_timeout_millis(self) -> Optional[pulumi.Input[_builtins.int]]:
        return pulumi.get(self, "request_timeout_millis")

    @request_timeout_millis.setter
    def request_timeout_millis(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "request_timeout_millis", value)

    @_builtins.property
    @pulumi.getter(name="staticValues")
    def static_values(self) -> Optional[pulumi.Input[_builtins.bool]]:
        return pulumi.get(self, "static_values")

    @static_values.setter
    def static_values(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_values", value)

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

    @url_path.setter
    def url_path(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "url_path", value)

    @_builtins.property
    @pulumi.getter(name="useXhr")
    def use_xhr(self) -> Optional[pulumi.Input[_builtins.bool]]:
        return pulumi.get(self, "use_xhr")

    @use_xhr.setter
    def use_xhr(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "use_xhr", value)


class PulsarJobWeightArgsDict(TypedDict):
    default_value: pulumi.Input[_builtins.float]
    name: pulumi.Input[_builtins.str]
    weight: pulumi.Input[_builtins.int]
    maximize: NotRequired[pulumi.Input[_builtins.bool]]

@pulumi.input_type
class PulsarJobWeightArgs:
    def __init__(__self__, *,
                 default_value: pulumi.Input[_builtins.float],
                 name: pulumi.Input[_builtins.str],
                 weight: pulumi.Input[_builtins.int],
                 maximize: Optional[pulumi.Input[_builtins.bool]] = None):
        pulumi.set(__self__, "default_value", default_value)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "weight", weight)
        if maximize is not None:
            pulumi.set(__self__, "maximize", maximize)

    @_builtins.property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> pulumi.Input[_builtins.float]:
        return pulumi.get(self, "default_value")

    @default_value.setter
    def default_value(self, value: pulumi.Input[_builtins.float]):
        pulumi.set(self, "default_value", value)

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

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def weight(self) -> pulumi.Input[_builtins.int]:
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "weight", value)

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

    @maximize.setter
    def maximize(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "maximize", value)


class RecordAnswerArgsDict(TypedDict):
    answer: NotRequired[pulumi.Input[_builtins.str]]
    """
    Space delimited string of RDATA fields dependent on the record type.

    A:

    answer = "1.2.3.4"

    CNAME:

    answer = "www.example.com"

    MX:

    answer = "5 mail.example.com"

    SRV:

    answer = "10 0 2380 node-1.example.com"

    SPF:

    answer = "v=DKIM1; k=rsa; p=XXXXXXXX"

    Optionally, the individual parts of the answer can be expressed as a list in the field `answer_parts`.
    Only one of `answer` or `answer_parts` can be specified.
    """
    answer_parts: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
    """
    A list of individual RDATA fields. This field cannot be set together with `answer`
    """
    meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
    """
    meta is supported at the `regions` level. Meta
    is documented below.
    Note that `Meta` values for `country`, `ca_province`, `georegion`, and
    `us_state` should be comma separated strings, and changes in ordering will not
    lead to terraform detecting a change.

    Note: regions **must** be sorted lexically by their "name" argument in the
    Terraform configuration file, otherwise Terraform will detect changes to the
    record when none actually exist.
    """
    region: NotRequired[pulumi.Input[_builtins.str]]
    """
    The region (Answer Group really) that this answer
    belongs to. This should be one of the names specified in `regions`. Only a
    single `region` per answer is currently supported. If you want an answer in
    multiple regions, duplicating the answer (including metadata) is the correct
    approach.
    * ` meta` - (Optional) meta is supported at the `answer` level. Meta
    is documented below.
    """

@pulumi.input_type
class RecordAnswerArgs:
    def __init__(__self__, *,
                 answer: Optional[pulumi.Input[_builtins.str]] = None,
                 answer_parts: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 region: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] answer: Space delimited string of RDATA fields dependent on the record type.
               
               A:
               
               answer = "1.2.3.4"
               
               CNAME:
               
               answer = "www.example.com"
               
               MX:
               
               answer = "5 mail.example.com"
               
               SRV:
               
               answer = "10 0 2380 node-1.example.com"
               
               SPF:
               
               answer = "v=DKIM1; k=rsa; p=XXXXXXXX"
               
               Optionally, the individual parts of the answer can be expressed as a list in the field `answer_parts`.
               Only one of `answer` or `answer_parts` can be specified.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] answer_parts: A list of individual RDATA fields. This field cannot be set together with `answer`
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] meta: meta is supported at the `regions` level. Meta
               is documented below.
               Note that `Meta` values for `country`, `ca_province`, `georegion`, and
               `us_state` should be comma separated strings, and changes in ordering will not
               lead to terraform detecting a change.
               
               Note: regions **must** be sorted lexically by their "name" argument in the
               Terraform configuration file, otherwise Terraform will detect changes to the
               record when none actually exist.
        :param pulumi.Input[_builtins.str] region: The region (Answer Group really) that this answer
               belongs to. This should be one of the names specified in `regions`. Only a
               single `region` per answer is currently supported. If you want an answer in
               multiple regions, duplicating the answer (including metadata) is the correct
               approach.
               * ` meta` - (Optional) meta is supported at the `answer` level. Meta
               is documented below.
        """
        if answer is not None:
            pulumi.set(__self__, "answer", answer)
        if answer_parts is not None:
            pulumi.set(__self__, "answer_parts", answer_parts)
        if meta is not None:
            pulumi.set(__self__, "meta", meta)
        if region is not None:
            pulumi.set(__self__, "region", region)

    @_builtins.property
    @pulumi.getter
    def answer(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Space delimited string of RDATA fields dependent on the record type.

        A:

        answer = "1.2.3.4"

        CNAME:

        answer = "www.example.com"

        MX:

        answer = "5 mail.example.com"

        SRV:

        answer = "10 0 2380 node-1.example.com"

        SPF:

        answer = "v=DKIM1; k=rsa; p=XXXXXXXX"

        Optionally, the individual parts of the answer can be expressed as a list in the field `answer_parts`.
        Only one of `answer` or `answer_parts` can be specified.
        """
        return pulumi.get(self, "answer")

    @answer.setter
    def answer(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "answer", value)

    @_builtins.property
    @pulumi.getter(name="answerParts")
    def answer_parts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        A list of individual RDATA fields. This field cannot be set together with `answer`
        """
        return pulumi.get(self, "answer_parts")

    @answer_parts.setter
    def answer_parts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "answer_parts", value)

    @_builtins.property
    @pulumi.getter
    def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        meta is supported at the `regions` level. Meta
        is documented below.
        Note that `Meta` values for `country`, `ca_province`, `georegion`, and
        `us_state` should be comma separated strings, and changes in ordering will not
        lead to terraform detecting a change.

        Note: regions **must** be sorted lexically by their "name" argument in the
        Terraform configuration file, otherwise Terraform will detect changes to the
        record when none actually exist.
        """
        return pulumi.get(self, "meta")

    @meta.setter
    def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "meta", value)

    @_builtins.property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The region (Answer Group really) that this answer
        belongs to. This should be one of the names specified in `regions`. Only a
        single `region` per answer is currently supported. If you want an answer in
        multiple regions, duplicating the answer (including metadata) is the correct
        approach.
        * ` meta` - (Optional) meta is supported at the `answer` level. Meta
        is documented below.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "region", value)


class RecordFilterArgsDict(TypedDict):
    filter: pulumi.Input[_builtins.str]
    """
    The type of filter.
    """
    config: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
    """
    The filters' configuration. Simple key/value pairs determined by the filter type.
    """
    disabled: NotRequired[pulumi.Input[_builtins.bool]]
    """
    Determines whether the filter is applied in the filter chain.
    """

@pulumi.input_type
class RecordFilterArgs:
    def __init__(__self__, *,
                 filter: pulumi.Input[_builtins.str],
                 config: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 disabled: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] filter: The type of filter.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] config: The filters' configuration. Simple key/value pairs determined by the filter type.
        :param pulumi.Input[_builtins.bool] disabled: Determines whether the filter is applied in the filter chain.
        """
        pulumi.set(__self__, "filter", filter)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @_builtins.property
    @pulumi.getter
    def filter(self) -> pulumi.Input[_builtins.str]:
        """
        The type of filter.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "filter", value)

    @_builtins.property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        The filters' configuration. Simple key/value pairs determined by the filter type.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "config", value)

    @_builtins.property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Determines whether the filter is applied in the filter chain.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "disabled", value)


class RecordRegionArgsDict(TypedDict):
    name: pulumi.Input[_builtins.str]
    """
    Name of the region (or Answer Group).
    """
    meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
    """
    meta is supported at the `regions` level. Meta
    is documented below.
    Note that `Meta` values for `country`, `ca_province`, `georegion`, and
    `us_state` should be comma separated strings, and changes in ordering will not
    lead to terraform detecting a change.

    Note: regions **must** be sorted lexically by their "name" argument in the
    Terraform configuration file, otherwise Terraform will detect changes to the
    record when none actually exist.
    """

@pulumi.input_type
class RecordRegionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] name: Name of the region (or Answer Group).
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] meta: meta is supported at the `regions` level. Meta
               is documented below.
               Note that `Meta` values for `country`, `ca_province`, `georegion`, and
               `us_state` should be comma separated strings, and changes in ordering will not
               lead to terraform detecting a change.
               
               Note: regions **must** be sorted lexically by their "name" argument in the
               Terraform configuration file, otherwise Terraform will detect changes to the
               record when none actually exist.
        """
        pulumi.set(__self__, "name", name)
        if meta is not None:
            pulumi.set(__self__, "meta", meta)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        Name of the region (or Answer Group).
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        meta is supported at the `regions` level. Meta
        is documented below.
        Note that `Meta` values for `country`, `ca_province`, `georegion`, and
        `us_state` should be comma separated strings, and changes in ordering will not
        lead to terraform detecting a change.

        Note: regions **must** be sorted lexically by their "name" argument in the
        Terraform configuration file, otherwise Terraform will detect changes to the
        record when none actually exist.
        """
        return pulumi.get(self, "meta")

    @meta.setter
    def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "meta", value)


class TeamDnsRecordsAllowArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class TeamDnsRecordsAllowArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class TeamDnsRecordsDenyArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class TeamDnsRecordsDenyArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class TeamIpWhitelistArgsDict(TypedDict):
    name: pulumi.Input[_builtins.str]
    """
    The free form name of the team.
    """
    values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]

@pulumi.input_type
class TeamIpWhitelistArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
        """
        :param pulumi.Input[_builtins.str] name: The free form name of the team.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        The free form name of the team.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

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

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
        pulumi.set(self, "values", value)


class UserDnsRecordsAllowArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class UserDnsRecordsAllowArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class UserDnsRecordsDenyArgsDict(TypedDict):
    domain: pulumi.Input[_builtins.str]
    include_subdomains: pulumi.Input[_builtins.bool]
    type: pulumi.Input[_builtins.str]
    zone: pulumi.Input[_builtins.str]

@pulumi.input_type
class UserDnsRecordsDenyArgs:
    def __init__(__self__, *,
                 domain: pulumi.Input[_builtins.str],
                 include_subdomains: pulumi.Input[_builtins.bool],
                 type: pulumi.Input[_builtins.str],
                 zone: pulumi.Input[_builtins.str]):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "include_subdomains", include_subdomains)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "zone", zone)

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

    @domain.setter
    def domain(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "domain", value)

    @_builtins.property
    @pulumi.getter(name="includeSubdomains")
    def include_subdomains(self) -> pulumi.Input[_builtins.bool]:
        return pulumi.get(self, "include_subdomains")

    @include_subdomains.setter
    def include_subdomains(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "include_subdomains", value)

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

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

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

    @zone.setter
    def zone(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "zone", value)


class ZoneSecondaryArgsDict(TypedDict):
    ip: pulumi.Input[_builtins.str]
    """
    IPv4 address of the secondary server.
    """
    networks: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
    """
    List of network IDs (`int`) for which the zone
    should be made available. Default is network 0, the primary NSONE Global
    Network. Normally, you should not have to worry about this.
    """
    notify: NotRequired[pulumi.Input[_builtins.bool]]
    """
    Whether we send `NOTIFY` messages to the secondary host when the zone changes. Default `false`.
    """
    port: NotRequired[pulumi.Input[_builtins.int]]
    """
    Port of the the secondary server.
    """

@pulumi.input_type
class ZoneSecondaryArgs:
    def __init__(__self__, *,
                 ip: pulumi.Input[_builtins.str],
                 networks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
                 notify: Optional[pulumi.Input[_builtins.bool]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] ip: IPv4 address of the secondary server.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] networks: List of network IDs (`int`) for which the zone
               should be made available. Default is network 0, the primary NSONE Global
               Network. Normally, you should not have to worry about this.
        :param pulumi.Input[_builtins.bool] notify: Whether we send `NOTIFY` messages to the secondary host when the zone changes. Default `false`.
        :param pulumi.Input[_builtins.int] port: Port of the the secondary server.
        """
        pulumi.set(__self__, "ip", ip)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if notify is not None:
            pulumi.set(__self__, "notify", notify)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @_builtins.property
    @pulumi.getter
    def ip(self) -> pulumi.Input[_builtins.str]:
        """
        IPv4 address of the secondary server.
        """
        return pulumi.get(self, "ip")

    @ip.setter
    def ip(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "ip", value)

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
        """
        List of network IDs (`int`) for which the zone
        should be made available. Default is network 0, the primary NSONE Global
        Network. Normally, you should not have to worry about this.
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
        pulumi.set(self, "networks", value)

    @_builtins.property
    @pulumi.getter
    def notify(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether we send `NOTIFY` messages to the secondary host when the zone changes. Default `false`.
        """
        return pulumi.get(self, "notify")

    @notify.setter
    def notify(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "notify", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port of the the secondary server.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)


class GetMonitoringRegionsRegionArgsDict(TypedDict):
    code: NotRequired[_builtins.str]
    """
    3-letter city code identifying the location of the monitor.
    """
    name: NotRequired[_builtins.str]
    """
    City name identifying the location of the monitor.
    """
    subnets: NotRequired[Sequence[_builtins.str]]
    """
    A list of IPv4 and IPv6 subnets the monitor sources requests from.
    """

@pulumi.input_type
class GetMonitoringRegionsRegionArgs:
    def __init__(__self__, *,
                 code: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 subnets: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.str code: 3-letter city code identifying the location of the monitor.
        :param _builtins.str name: City name identifying the location of the monitor.
        :param Sequence[_builtins.str] subnets: A list of IPv4 and IPv6 subnets the monitor sources requests from.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)

    @_builtins.property
    @pulumi.getter
    def code(self) -> Optional[_builtins.str]:
        """
        3-letter city code identifying the location of the monitor.
        """
        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[_builtins.str]):
        pulumi.set(self, "code", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        City name identifying the location of the monitor.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[_builtins.str]]:
        """
        A list of IPv4 and IPv6 subnets the monitor sources requests from.
        """
        return pulumi.get(self, "subnets")

    @subnets.setter
    def subnets(self, value: Optional[Sequence[_builtins.str]]):
        pulumi.set(self, "subnets", value)


