pulumi-ns1 3.2.0a1710157241__py3-none-any.whl → 3.6.0a1736834553__py3-none-any.whl

pulumi_ns1/_inputs.py

@@ -4,31 +4,74 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
     'APIKeyDnsRecordsAllowArgs',
+    'APIKeyDnsRecordsAllowArgsDict',
     'APIKeyDnsRecordsDenyArgs',
+    'APIKeyDnsRecordsDenyArgsDict',
     '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',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class APIKeyDnsRecordsAllowArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    APIKeyDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class APIKeyDnsRecordsAllowArgs:
     def __init__(__self__, *,
@@ -78,6 +121,15 @@ class APIKeyDnsRecordsAllowArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class APIKeyDnsRecordsDenyArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    APIKeyDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class APIKeyDnsRecordsDenyArgs:
     def __init__(__self__, *,
@@ -127,6 +179,36 @@ class APIKeyDnsRecordsDenyArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class ApplicationDefaultConfigArgsDict(TypedDict):
+        http: pulumi.Input[bool]
+        """
+        Indicates whether or not to use HTTP in measurements.
+        """
+        https: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates whether or not to use HTTPS in measurements.
+        """
+        job_timeout_millis: NotRequired[pulumi.Input[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[int]]
+        """
+        Maximum timeout per request.
+        """
+        static_values: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates whether or not to skip aggregation for this job's measurements
+        """
+        use_xhr: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to use XMLHttpRequest (XHR) when taking measurements.
+        """
+elif False:
+    ApplicationDefaultConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ApplicationDefaultConfigArgs:
     def __init__(__self__, *,
@@ -231,6 +313,242 @@ class ApplicationDefaultConfigArgs:
         pulumi.set(self, "use_xhr", value)
 
 
+if not MYPY:
+    class DatasetDatatypeArgsDict(TypedDict):
+        data: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        scope: pulumi.Input[str]
+        type: pulumi.Input[str]
+elif False:
+    DatasetDatatypeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatasetDatatypeArgs:
+    def __init__(__self__, *,
+                 data: pulumi.Input[Mapping[str, pulumi.Input[str]]],
+                 scope: pulumi.Input[str],
+                 type: pulumi.Input[str]):
+        pulumi.set(__self__, "data", data)
+        pulumi.set(__self__, "scope", scope)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def data(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
+        return pulumi.get(self, "data")
+
+    @data.setter
+    def data(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
+        pulumi.set(self, "data", value)
+
+    @property
+    @pulumi.getter
+    def scope(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "scope")
+
+    @scope.setter
+    def scope(self, value: pulumi.Input[str]):
+        pulumi.set(self, "scope", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "type", value)
+
+
+if not MYPY:
+    class DatasetRepeatArgsDict(TypedDict):
+        end_after_n: pulumi.Input[int]
+        repeats_every: pulumi.Input[str]
+        start: pulumi.Input[int]
+elif False:
+    DatasetRepeatArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatasetRepeatArgs:
+    def __init__(__self__, *,
+                 end_after_n: pulumi.Input[int],
+                 repeats_every: pulumi.Input[str],
+                 start: pulumi.Input[int]):
+        pulumi.set(__self__, "end_after_n", end_after_n)
+        pulumi.set(__self__, "repeats_every", repeats_every)
+        pulumi.set(__self__, "start", start)
+
+    @property
+    @pulumi.getter(name="endAfterN")
+    def end_after_n(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "end_after_n")
+
+    @end_after_n.setter
+    def end_after_n(self, value: pulumi.Input[int]):
+        pulumi.set(self, "end_after_n", value)
+
+    @property
+    @pulumi.getter(name="repeatsEvery")
+    def repeats_every(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "repeats_every")
+
+    @repeats_every.setter
+    def repeats_every(self, value: pulumi.Input[str]):
+        pulumi.set(self, "repeats_every", value)
+
+    @property
+    @pulumi.getter
+    def start(self) -> pulumi.Input[int]:
+        return pulumi.get(self, "start")
+
+    @start.setter
+    def start(self, value: pulumi.Input[int]):
+        pulumi.set(self, "start", value)
+
+
+if not MYPY:
+    class DatasetReportArgsDict(TypedDict):
+        created_at: NotRequired[pulumi.Input[int]]
+        end: NotRequired[pulumi.Input[int]]
+        id: NotRequired[pulumi.Input[str]]
+        start: NotRequired[pulumi.Input[int]]
+        status: NotRequired[pulumi.Input[str]]
+elif False:
+    DatasetReportArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatasetReportArgs:
+    def __init__(__self__, *,
+                 created_at: Optional[pulumi.Input[int]] = None,
+                 end: Optional[pulumi.Input[int]] = None,
+                 id: Optional[pulumi.Input[str]] = None,
+                 start: Optional[pulumi.Input[int]] = None,
+                 status: Optional[pulumi.Input[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)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "created_at")
+
+    @created_at.setter
+    def created_at(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "created_at", value)
+
+    @property
+    @pulumi.getter
+    def end(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "end")
+
+    @end.setter
+    def end(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "end", value)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def start(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "start")
+
+    @start.setter
+    def start(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "start", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "status", value)
+
+
+if not MYPY:
+    class DatasetTimeframeArgsDict(TypedDict):
+        aggregation: pulumi.Input[str]
+        cycles: NotRequired[pulumi.Input[int]]
+        from_: NotRequired[pulumi.Input[int]]
+        to: NotRequired[pulumi.Input[int]]
+elif False:
+    DatasetTimeframeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatasetTimeframeArgs:
+    def __init__(__self__, *,
+                 aggregation: pulumi.Input[str],
+                 cycles: Optional[pulumi.Input[int]] = None,
+                 from_: Optional[pulumi.Input[int]] = None,
+                 to: Optional[pulumi.Input[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)
+
+    @property
+    @pulumi.getter
+    def aggregation(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "aggregation")
+
+    @aggregation.setter
+    def aggregation(self, value: pulumi.Input[str]):
+        pulumi.set(self, "aggregation", value)
+
+    @property
+    @pulumi.getter
+    def cycles(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "cycles")
+
+    @cycles.setter
+    def cycles(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "cycles", value)
+
+    @property
+    @pulumi.getter(name="from")
+    def from_(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "from_")
+
+    @from_.setter
+    def from_(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "from_", value)
+
+    @property
+    @pulumi.getter
+    def to(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class MonitoringJobRuleArgsDict(TypedDict):
+        comparison: pulumi.Input[str]
+        key: pulumi.Input[str]
+        value: pulumi.Input[str]
+elif False:
+    MonitoringJobRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MonitoringJobRuleArgs:
     def __init__(__self__, *,
@@ -269,13 +587,26 @@ class MonitoringJobRuleArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class NotifyListNotificationArgsDict(TypedDict):
+        config: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Configuration details for the given notifier type.
+        """
+        type: pulumi.Input[str]
+        """
+        The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
+        """
+elif False:
+    NotifyListNotificationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NotifyListNotificationArgs:
     def __init__(__self__, *,
-                 config: pulumi.Input[Mapping[str, Any]],
+                 config: pulumi.Input[Mapping[str, pulumi.Input[str]]],
                  type: pulumi.Input[str]):
         """
-        :param pulumi.Input[Mapping[str, Any]] config: Configuration details for the given notifier type.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] config: Configuration details for the given notifier type.
         :param pulumi.Input[str] type: The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
         """
         pulumi.set(__self__, "config", config)
@@ -283,14 +614,14 @@ class NotifyListNotificationArgs:
 
     @property
     @pulumi.getter
-    def config(self) -> pulumi.Input[Mapping[str, Any]]:
+    def config(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
         """
         Configuration details for the given notifier type.
         """
         return pulumi.get(self, "config")
 
     @config.setter
-    def config(self, value: pulumi.Input[Mapping[str, Any]]):
+    def config(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
         pulumi.set(self, "config", value)
 
     @property
@@ -306,6 +637,12 @@ class NotifyListNotificationArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class PulsarJobBlendMetricWeightsArgsDict(TypedDict):
+        timestamp: pulumi.Input[int]
+elif False:
+    PulsarJobBlendMetricWeightsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PulsarJobBlendMetricWeightsArgs:
     def __init__(__self__, *,
@@ -322,6 +659,19 @@ class PulsarJobBlendMetricWeightsArgs:
         pulumi.set(self, "timestamp", value)
 
 
+if not MYPY:
+    class PulsarJobConfigArgsDict(TypedDict):
+        host: NotRequired[pulumi.Input[str]]
+        http: NotRequired[pulumi.Input[bool]]
+        https: NotRequired[pulumi.Input[bool]]
+        job_timeout_millis: NotRequired[pulumi.Input[int]]
+        request_timeout_millis: NotRequired[pulumi.Input[int]]
+        static_values: NotRequired[pulumi.Input[bool]]
+        url_path: NotRequired[pulumi.Input[str]]
+        use_xhr: NotRequired[pulumi.Input[bool]]
+elif False:
+    PulsarJobConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PulsarJobConfigArgs:
     def __init__(__self__, *,
@@ -423,6 +773,15 @@ class PulsarJobConfigArgs:
         pulumi.set(self, "use_xhr", value)
 
 
+if not MYPY:
+    class PulsarJobWeightArgsDict(TypedDict):
+        default_value: pulumi.Input[float]
+        name: pulumi.Input[str]
+        weight: pulumi.Input[int]
+        maximize: NotRequired[pulumi.Input[bool]]
+elif False:
+    PulsarJobWeightArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class PulsarJobWeightArgs:
     def __init__(__self__, *,
@@ -473,11 +832,51 @@ class PulsarJobWeightArgs:
         pulumi.set(self, "maximize", value)
 
 
+if not MYPY:
+    class RecordAnswerArgsDict(TypedDict):
+        answer: NotRequired[pulumi.Input[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"
+        """
+        meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        region: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    RecordAnswerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordAnswerArgs:
     def __init__(__self__, *,
                  answer: Optional[pulumi.Input[str]] = None,
-                 meta: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  region: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] answer: Space delimited string of RDATA fields dependent on the record type.
@@ -550,11 +949,11 @@ class RecordAnswerArgs:
 
     @property
     @pulumi.getter
-    def meta(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         return pulumi.get(self, "meta")
 
     @meta.setter
-    def meta(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "meta", value)
 
     @property
@@ -576,15 +975,34 @@ class RecordAnswerArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class RecordFilterArgsDict(TypedDict):
+        filter: pulumi.Input[str]
+        """
+        The type of filter.
+        """
+        config: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The filters' configuration. Simple key/value pairs
+        determined by the filter type.
+        """
+        disabled: NotRequired[pulumi.Input[bool]]
+        """
+        Determines whether the filter is applied in the
+        filter chain.
+        """
+elif False:
+    RecordFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordFilterArgs:
     def __init__(__self__, *,
                  filter: pulumi.Input[str],
-                 config: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 config: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  disabled: Optional[pulumi.Input[bool]] = None):
         """
         :param pulumi.Input[str] filter: The type of filter.
-        :param pulumi.Input[Mapping[str, Any]] config: The filters' configuration. Simple key/value pairs
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] config: The filters' configuration. Simple key/value pairs
                determined by the filter type.
         :param pulumi.Input[bool] disabled: Determines whether the filter is applied in the
                filter chain.
@@ -609,7 +1027,7 @@ class RecordFilterArgs:
 
     @property
     @pulumi.getter
-    def config(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def config(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         The filters' configuration. Simple key/value pairs
         determined by the filter type.
@@ -617,7 +1035,7 @@ class RecordFilterArgs:
         return pulumi.get(self, "config")
 
     @config.setter
-    def config(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def config(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "config", value)
 
     @property
@@ -634,11 +1052,21 @@ class RecordFilterArgs:
         pulumi.set(self, "disabled", value)
 
 
+if not MYPY:
+    class RecordRegionArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        Name of the region (or Answer Group).
+        """
+        meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+elif False:
+    RecordRegionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RecordRegionArgs:
     def __init__(__self__, *,
                  name: pulumi.Input[str],
-                 meta: Optional[pulumi.Input[Mapping[str, Any]]] = None):
+                 meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[str] name: Name of the region (or Answer Group).
         """
@@ -660,14 +1088,23 @@ class RecordRegionArgs:
 
     @property
     @pulumi.getter
-    def meta(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         return pulumi.get(self, "meta")
 
     @meta.setter
-    def meta(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "meta", value)
 
 
+if not MYPY:
+    class TeamDnsRecordsAllowArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    TeamDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TeamDnsRecordsAllowArgs:
     def __init__(__self__, *,
@@ -717,6 +1154,15 @@ class TeamDnsRecordsAllowArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class TeamDnsRecordsDenyArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    TeamDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TeamDnsRecordsDenyArgs:
     def __init__(__self__, *,
@@ -766,6 +1212,16 @@ class TeamDnsRecordsDenyArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class TeamIpWhitelistArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        The free form name of the team.
+        """
+        values: pulumi.Input[Sequence[pulumi.Input[str]]]
+elif False:
+    TeamIpWhitelistArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TeamIpWhitelistArgs:
     def __init__(__self__, *,
@@ -799,6 +1255,15 @@ class TeamIpWhitelistArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class UserDnsRecordsAllowArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    UserDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UserDnsRecordsAllowArgs:
     def __init__(__self__, *,
@@ -848,6 +1313,15 @@ class UserDnsRecordsAllowArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class UserDnsRecordsDenyArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        include_subdomains: pulumi.Input[bool]
+        type: pulumi.Input[str]
+        zone: pulumi.Input[str]
+elif False:
+    UserDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UserDnsRecordsDenyArgs:
     def __init__(__self__, *,
@@ -897,6 +1371,30 @@ class UserDnsRecordsDenyArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class ZoneSecondaryArgsDict(TypedDict):
+        ip: pulumi.Input[str]
+        """
+        IPv4 address of the secondary server.
+        """
+        networks: NotRequired[pulumi.Input[Sequence[pulumi.Input[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[bool]]
+        """
+        Whether we send `NOTIFY` messages to the secondary host
+        when the zone changes. Default `false`.
+        """
+        port: NotRequired[pulumi.Input[int]]
+        """
+        Port of the the secondary server. Default `53`.
+        """
+elif False:
+    ZoneSecondaryArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ZoneSecondaryArgs:
     def __init__(__self__, *,
@@ -973,3 +1471,75 @@ class ZoneSecondaryArgs:
         pulumi.set(self, "port", value)
 
 
+if not MYPY:
+    class GetMonitoringRegionsRegionArgsDict(TypedDict):
+        code: NotRequired[str]
+        """
+        3-letter city code identifying the location of the monitor.
+        """
+        name: NotRequired[str]
+        """
+        City name identifying the location of the monitor.
+        """
+        subnets: NotRequired[Sequence[str]]
+        """
+        A list of IPv4 and IPv6 subnets the monitor sources requests from.
+        """
+elif False:
+    GetMonitoringRegionsRegionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetMonitoringRegionsRegionArgs:
+    def __init__(__self__, *,
+                 code: Optional[str] = None,
+                 name: Optional[str] = None,
+                 subnets: Optional[Sequence[str]] = None):
+        """
+        :param str code: 3-letter city code identifying the location of the monitor.
+        :param str name: City name identifying the location of the monitor.
+        :param Sequence[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)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[str]:
+        """
+        3-letter city code identifying the location of the monitor.
+        """
+        return pulumi.get(self, "code")
+
+    @code.setter
+    def code(self, value: Optional[str]):
+        pulumi.set(self, "code", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        City name identifying the location of the monitor.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def subnets(self) -> Optional[Sequence[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[str]]):
+        pulumi.set(self, "subnets", value)
+
+