pulumi-ns1 3.6.2__py3-none-any.whl → 3.6.3a1746675071__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_ns1/__init__.py +1 -0
- pulumi_ns1/_inputs.py +344 -343
- pulumi_ns1/account_whitelist.py +32 -28
- pulumi_ns1/alert.py +116 -112
- pulumi_ns1/api_key.py +419 -415
- pulumi_ns1/application.py +62 -58
- pulumi_ns1/config/__init__.py +1 -0
- pulumi_ns1/config/__init__.pyi +1 -0
- pulumi_ns1/config/vars.py +1 -0
- pulumi_ns1/data_feed.py +46 -42
- pulumi_ns1/data_source.py +46 -42
- pulumi_ns1/dataset.py +34 -30
- pulumi_ns1/dnsview.py +74 -70
- pulumi_ns1/get_billing_usage.py +30 -29
- pulumi_ns1/get_dns_sec.py +7 -6
- pulumi_ns1/get_monitoring_regions.py +2 -1
- pulumi_ns1/get_networks.py +2 -1
- pulumi_ns1/get_record.py +25 -24
- pulumi_ns1/get_zone.py +33 -32
- pulumi_ns1/monitoring_job.py +210 -206
- pulumi_ns1/notify_list.py +18 -14
- pulumi_ns1/outputs.py +292 -291
- pulumi_ns1/provider.py +49 -45
- pulumi_ns1/pulsar_job.py +69 -65
- pulumi_ns1/pulumi-plugin.json +1 -1
- pulumi_ns1/record.py +152 -148
- pulumi_ns1/redirect.py +140 -136
- pulumi_ns1/redirect_certificate.py +39 -35
- pulumi_ns1/team.py +368 -364
- pulumi_ns1/tsigkey.py +46 -42
- pulumi_ns1/user.py +452 -448
- pulumi_ns1/zone.py +316 -244
- {pulumi_ns1-3.6.2.dist-info → pulumi_ns1-3.6.3a1746675071.dist-info}/METADATA +1 -1
- pulumi_ns1-3.6.3a1746675071.dist-info/RECORD +38 -0
- {pulumi_ns1-3.6.2.dist-info → pulumi_ns1-3.6.3a1746675071.dist-info}/WHEEL +1 -1
- pulumi_ns1-3.6.2.dist-info/RECORD +0 -38
- {pulumi_ns1-3.6.2.dist-info → pulumi_ns1-3.6.3a1746675071.dist-info}/top_level.txt +0 -0
pulumi_ns1/_inputs.py
CHANGED
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
+
import builtins
|
|
5
6
|
import copy
|
|
6
7
|
import warnings
|
|
7
8
|
import sys
|
|
@@ -65,20 +66,20 @@ MYPY = False
|
|
|
65
66
|
|
|
66
67
|
if not MYPY:
|
|
67
68
|
class APIKeyDnsRecordsAllowArgsDict(TypedDict):
|
|
68
|
-
domain: pulumi.Input[str]
|
|
69
|
-
include_subdomains: pulumi.Input[bool]
|
|
70
|
-
type: pulumi.Input[str]
|
|
71
|
-
zone: pulumi.Input[str]
|
|
69
|
+
domain: pulumi.Input[builtins.str]
|
|
70
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
71
|
+
type: pulumi.Input[builtins.str]
|
|
72
|
+
zone: pulumi.Input[builtins.str]
|
|
72
73
|
elif False:
|
|
73
74
|
APIKeyDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
|
|
74
75
|
|
|
75
76
|
@pulumi.input_type
|
|
76
77
|
class APIKeyDnsRecordsAllowArgs:
|
|
77
78
|
def __init__(__self__, *,
|
|
78
|
-
domain: pulumi.Input[str],
|
|
79
|
-
include_subdomains: pulumi.Input[bool],
|
|
80
|
-
type: pulumi.Input[str],
|
|
81
|
-
zone: pulumi.Input[str]):
|
|
79
|
+
domain: pulumi.Input[builtins.str],
|
|
80
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
81
|
+
type: pulumi.Input[builtins.str],
|
|
82
|
+
zone: pulumi.Input[builtins.str]):
|
|
82
83
|
pulumi.set(__self__, "domain", domain)
|
|
83
84
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
84
85
|
pulumi.set(__self__, "type", type)
|
|
@@ -86,57 +87,57 @@ class APIKeyDnsRecordsAllowArgs:
|
|
|
86
87
|
|
|
87
88
|
@property
|
|
88
89
|
@pulumi.getter
|
|
89
|
-
def domain(self) -> pulumi.Input[str]:
|
|
90
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
90
91
|
return pulumi.get(self, "domain")
|
|
91
92
|
|
|
92
93
|
@domain.setter
|
|
93
|
-
def domain(self, value: pulumi.Input[str]):
|
|
94
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
94
95
|
pulumi.set(self, "domain", value)
|
|
95
96
|
|
|
96
97
|
@property
|
|
97
98
|
@pulumi.getter(name="includeSubdomains")
|
|
98
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
99
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
99
100
|
return pulumi.get(self, "include_subdomains")
|
|
100
101
|
|
|
101
102
|
@include_subdomains.setter
|
|
102
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
103
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
103
104
|
pulumi.set(self, "include_subdomains", value)
|
|
104
105
|
|
|
105
106
|
@property
|
|
106
107
|
@pulumi.getter
|
|
107
|
-
def type(self) -> pulumi.Input[str]:
|
|
108
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
108
109
|
return pulumi.get(self, "type")
|
|
109
110
|
|
|
110
111
|
@type.setter
|
|
111
|
-
def type(self, value: pulumi.Input[str]):
|
|
112
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
112
113
|
pulumi.set(self, "type", value)
|
|
113
114
|
|
|
114
115
|
@property
|
|
115
116
|
@pulumi.getter
|
|
116
|
-
def zone(self) -> pulumi.Input[str]:
|
|
117
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
117
118
|
return pulumi.get(self, "zone")
|
|
118
119
|
|
|
119
120
|
@zone.setter
|
|
120
|
-
def zone(self, value: pulumi.Input[str]):
|
|
121
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
121
122
|
pulumi.set(self, "zone", value)
|
|
122
123
|
|
|
123
124
|
|
|
124
125
|
if not MYPY:
|
|
125
126
|
class APIKeyDnsRecordsDenyArgsDict(TypedDict):
|
|
126
|
-
domain: pulumi.Input[str]
|
|
127
|
-
include_subdomains: pulumi.Input[bool]
|
|
128
|
-
type: pulumi.Input[str]
|
|
129
|
-
zone: pulumi.Input[str]
|
|
127
|
+
domain: pulumi.Input[builtins.str]
|
|
128
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
129
|
+
type: pulumi.Input[builtins.str]
|
|
130
|
+
zone: pulumi.Input[builtins.str]
|
|
130
131
|
elif False:
|
|
131
132
|
APIKeyDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
|
|
132
133
|
|
|
133
134
|
@pulumi.input_type
|
|
134
135
|
class APIKeyDnsRecordsDenyArgs:
|
|
135
136
|
def __init__(__self__, *,
|
|
136
|
-
domain: pulumi.Input[str],
|
|
137
|
-
include_subdomains: pulumi.Input[bool],
|
|
138
|
-
type: pulumi.Input[str],
|
|
139
|
-
zone: pulumi.Input[str]):
|
|
137
|
+
domain: pulumi.Input[builtins.str],
|
|
138
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
139
|
+
type: pulumi.Input[builtins.str],
|
|
140
|
+
zone: pulumi.Input[builtins.str]):
|
|
140
141
|
pulumi.set(__self__, "domain", domain)
|
|
141
142
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
142
143
|
pulumi.set(__self__, "type", type)
|
|
@@ -144,65 +145,65 @@ class APIKeyDnsRecordsDenyArgs:
|
|
|
144
145
|
|
|
145
146
|
@property
|
|
146
147
|
@pulumi.getter
|
|
147
|
-
def domain(self) -> pulumi.Input[str]:
|
|
148
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
148
149
|
return pulumi.get(self, "domain")
|
|
149
150
|
|
|
150
151
|
@domain.setter
|
|
151
|
-
def domain(self, value: pulumi.Input[str]):
|
|
152
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
152
153
|
pulumi.set(self, "domain", value)
|
|
153
154
|
|
|
154
155
|
@property
|
|
155
156
|
@pulumi.getter(name="includeSubdomains")
|
|
156
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
157
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
157
158
|
return pulumi.get(self, "include_subdomains")
|
|
158
159
|
|
|
159
160
|
@include_subdomains.setter
|
|
160
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
161
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
161
162
|
pulumi.set(self, "include_subdomains", value)
|
|
162
163
|
|
|
163
164
|
@property
|
|
164
165
|
@pulumi.getter
|
|
165
|
-
def type(self) -> pulumi.Input[str]:
|
|
166
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
166
167
|
return pulumi.get(self, "type")
|
|
167
168
|
|
|
168
169
|
@type.setter
|
|
169
|
-
def type(self, value: pulumi.Input[str]):
|
|
170
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
170
171
|
pulumi.set(self, "type", value)
|
|
171
172
|
|
|
172
173
|
@property
|
|
173
174
|
@pulumi.getter
|
|
174
|
-
def zone(self) -> pulumi.Input[str]:
|
|
175
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
175
176
|
return pulumi.get(self, "zone")
|
|
176
177
|
|
|
177
178
|
@zone.setter
|
|
178
|
-
def zone(self, value: pulumi.Input[str]):
|
|
179
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
179
180
|
pulumi.set(self, "zone", value)
|
|
180
181
|
|
|
181
182
|
|
|
182
183
|
if not MYPY:
|
|
183
184
|
class ApplicationDefaultConfigArgsDict(TypedDict):
|
|
184
|
-
http: pulumi.Input[bool]
|
|
185
|
+
http: pulumi.Input[builtins.bool]
|
|
185
186
|
"""
|
|
186
187
|
Indicates whether or not to use HTTP in measurements.
|
|
187
188
|
"""
|
|
188
|
-
https: NotRequired[pulumi.Input[bool]]
|
|
189
|
+
https: NotRequired[pulumi.Input[builtins.bool]]
|
|
189
190
|
"""
|
|
190
191
|
Indicates whether or not to use HTTPS in measurements.
|
|
191
192
|
"""
|
|
192
|
-
job_timeout_millis: NotRequired[pulumi.Input[int]]
|
|
193
|
+
job_timeout_millis: NotRequired[pulumi.Input[builtins.int]]
|
|
193
194
|
"""
|
|
194
195
|
Maximum timeout per job
|
|
195
196
|
0, the primary NSONE Global Network. Normally, you should not have to worry about this.
|
|
196
197
|
"""
|
|
197
|
-
request_timeout_millis: NotRequired[pulumi.Input[int]]
|
|
198
|
+
request_timeout_millis: NotRequired[pulumi.Input[builtins.int]]
|
|
198
199
|
"""
|
|
199
200
|
Maximum timeout per request.
|
|
200
201
|
"""
|
|
201
|
-
static_values: NotRequired[pulumi.Input[bool]]
|
|
202
|
+
static_values: NotRequired[pulumi.Input[builtins.bool]]
|
|
202
203
|
"""
|
|
203
204
|
Indicates whether or not to skip aggregation for this job's measurements
|
|
204
205
|
"""
|
|
205
|
-
use_xhr: NotRequired[pulumi.Input[bool]]
|
|
206
|
+
use_xhr: NotRequired[pulumi.Input[builtins.bool]]
|
|
206
207
|
"""
|
|
207
208
|
Whether to use XMLHttpRequest (XHR) when taking measurements.
|
|
208
209
|
"""
|
|
@@ -212,20 +213,20 @@ elif False:
|
|
|
212
213
|
@pulumi.input_type
|
|
213
214
|
class ApplicationDefaultConfigArgs:
|
|
214
215
|
def __init__(__self__, *,
|
|
215
|
-
http: pulumi.Input[bool],
|
|
216
|
-
https: Optional[pulumi.Input[bool]] = None,
|
|
217
|
-
job_timeout_millis: Optional[pulumi.Input[int]] = None,
|
|
218
|
-
request_timeout_millis: Optional[pulumi.Input[int]] = None,
|
|
219
|
-
static_values: Optional[pulumi.Input[bool]] = None,
|
|
220
|
-
use_xhr: Optional[pulumi.Input[bool]] = None):
|
|
221
|
-
"""
|
|
222
|
-
:param pulumi.Input[bool] http: Indicates whether or not to use HTTP in measurements.
|
|
223
|
-
:param pulumi.Input[bool] https: Indicates whether or not to use HTTPS in measurements.
|
|
224
|
-
:param pulumi.Input[int] job_timeout_millis: Maximum timeout per job
|
|
216
|
+
http: pulumi.Input[builtins.bool],
|
|
217
|
+
https: Optional[pulumi.Input[builtins.bool]] = None,
|
|
218
|
+
job_timeout_millis: Optional[pulumi.Input[builtins.int]] = None,
|
|
219
|
+
request_timeout_millis: Optional[pulumi.Input[builtins.int]] = None,
|
|
220
|
+
static_values: Optional[pulumi.Input[builtins.bool]] = None,
|
|
221
|
+
use_xhr: Optional[pulumi.Input[builtins.bool]] = None):
|
|
222
|
+
"""
|
|
223
|
+
:param pulumi.Input[builtins.bool] http: Indicates whether or not to use HTTP in measurements.
|
|
224
|
+
:param pulumi.Input[builtins.bool] https: Indicates whether or not to use HTTPS in measurements.
|
|
225
|
+
:param pulumi.Input[builtins.int] job_timeout_millis: Maximum timeout per job
|
|
225
226
|
0, the primary NSONE Global Network. Normally, you should not have to worry about this.
|
|
226
|
-
:param pulumi.Input[int] request_timeout_millis: Maximum timeout per request.
|
|
227
|
-
:param pulumi.Input[bool] static_values: Indicates whether or not to skip aggregation for this job's measurements
|
|
228
|
-
:param pulumi.Input[bool] use_xhr: Whether to use XMLHttpRequest (XHR) when taking measurements.
|
|
227
|
+
:param pulumi.Input[builtins.int] request_timeout_millis: Maximum timeout per request.
|
|
228
|
+
:param pulumi.Input[builtins.bool] static_values: Indicates whether or not to skip aggregation for this job's measurements
|
|
229
|
+
:param pulumi.Input[builtins.bool] use_xhr: Whether to use XMLHttpRequest (XHR) when taking measurements.
|
|
229
230
|
"""
|
|
230
231
|
pulumi.set(__self__, "http", http)
|
|
231
232
|
if https is not None:
|
|
@@ -241,31 +242,31 @@ class ApplicationDefaultConfigArgs:
|
|
|
241
242
|
|
|
242
243
|
@property
|
|
243
244
|
@pulumi.getter
|
|
244
|
-
def http(self) -> pulumi.Input[bool]:
|
|
245
|
+
def http(self) -> pulumi.Input[builtins.bool]:
|
|
245
246
|
"""
|
|
246
247
|
Indicates whether or not to use HTTP in measurements.
|
|
247
248
|
"""
|
|
248
249
|
return pulumi.get(self, "http")
|
|
249
250
|
|
|
250
251
|
@http.setter
|
|
251
|
-
def http(self, value: pulumi.Input[bool]):
|
|
252
|
+
def http(self, value: pulumi.Input[builtins.bool]):
|
|
252
253
|
pulumi.set(self, "http", value)
|
|
253
254
|
|
|
254
255
|
@property
|
|
255
256
|
@pulumi.getter
|
|
256
|
-
def https(self) -> Optional[pulumi.Input[bool]]:
|
|
257
|
+
def https(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
257
258
|
"""
|
|
258
259
|
Indicates whether or not to use HTTPS in measurements.
|
|
259
260
|
"""
|
|
260
261
|
return pulumi.get(self, "https")
|
|
261
262
|
|
|
262
263
|
@https.setter
|
|
263
|
-
def https(self, value: Optional[pulumi.Input[bool]]):
|
|
264
|
+
def https(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
264
265
|
pulumi.set(self, "https", value)
|
|
265
266
|
|
|
266
267
|
@property
|
|
267
268
|
@pulumi.getter(name="jobTimeoutMillis")
|
|
268
|
-
def job_timeout_millis(self) -> Optional[pulumi.Input[int]]:
|
|
269
|
+
def job_timeout_millis(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
269
270
|
"""
|
|
270
271
|
Maximum timeout per job
|
|
271
272
|
0, the primary NSONE Global Network. Normally, you should not have to worry about this.
|
|
@@ -273,156 +274,156 @@ class ApplicationDefaultConfigArgs:
|
|
|
273
274
|
return pulumi.get(self, "job_timeout_millis")
|
|
274
275
|
|
|
275
276
|
@job_timeout_millis.setter
|
|
276
|
-
def job_timeout_millis(self, value: Optional[pulumi.Input[int]]):
|
|
277
|
+
def job_timeout_millis(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
277
278
|
pulumi.set(self, "job_timeout_millis", value)
|
|
278
279
|
|
|
279
280
|
@property
|
|
280
281
|
@pulumi.getter(name="requestTimeoutMillis")
|
|
281
|
-
def request_timeout_millis(self) -> Optional[pulumi.Input[int]]:
|
|
282
|
+
def request_timeout_millis(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
282
283
|
"""
|
|
283
284
|
Maximum timeout per request.
|
|
284
285
|
"""
|
|
285
286
|
return pulumi.get(self, "request_timeout_millis")
|
|
286
287
|
|
|
287
288
|
@request_timeout_millis.setter
|
|
288
|
-
def request_timeout_millis(self, value: Optional[pulumi.Input[int]]):
|
|
289
|
+
def request_timeout_millis(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
289
290
|
pulumi.set(self, "request_timeout_millis", value)
|
|
290
291
|
|
|
291
292
|
@property
|
|
292
293
|
@pulumi.getter(name="staticValues")
|
|
293
|
-
def static_values(self) -> Optional[pulumi.Input[bool]]:
|
|
294
|
+
def static_values(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
294
295
|
"""
|
|
295
296
|
Indicates whether or not to skip aggregation for this job's measurements
|
|
296
297
|
"""
|
|
297
298
|
return pulumi.get(self, "static_values")
|
|
298
299
|
|
|
299
300
|
@static_values.setter
|
|
300
|
-
def static_values(self, value: Optional[pulumi.Input[bool]]):
|
|
301
|
+
def static_values(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
301
302
|
pulumi.set(self, "static_values", value)
|
|
302
303
|
|
|
303
304
|
@property
|
|
304
305
|
@pulumi.getter(name="useXhr")
|
|
305
|
-
def use_xhr(self) -> Optional[pulumi.Input[bool]]:
|
|
306
|
+
def use_xhr(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
306
307
|
"""
|
|
307
308
|
Whether to use XMLHttpRequest (XHR) when taking measurements.
|
|
308
309
|
"""
|
|
309
310
|
return pulumi.get(self, "use_xhr")
|
|
310
311
|
|
|
311
312
|
@use_xhr.setter
|
|
312
|
-
def use_xhr(self, value: Optional[pulumi.Input[bool]]):
|
|
313
|
+
def use_xhr(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
313
314
|
pulumi.set(self, "use_xhr", value)
|
|
314
315
|
|
|
315
316
|
|
|
316
317
|
if not MYPY:
|
|
317
318
|
class DatasetDatatypeArgsDict(TypedDict):
|
|
318
|
-
data: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
319
|
-
scope: pulumi.Input[str]
|
|
320
|
-
type: pulumi.Input[str]
|
|
319
|
+
data: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
320
|
+
scope: pulumi.Input[builtins.str]
|
|
321
|
+
type: pulumi.Input[builtins.str]
|
|
321
322
|
elif False:
|
|
322
323
|
DatasetDatatypeArgsDict: TypeAlias = Mapping[str, Any]
|
|
323
324
|
|
|
324
325
|
@pulumi.input_type
|
|
325
326
|
class DatasetDatatypeArgs:
|
|
326
327
|
def __init__(__self__, *,
|
|
327
|
-
data: pulumi.Input[Mapping[str, pulumi.Input[str]]],
|
|
328
|
-
scope: pulumi.Input[str],
|
|
329
|
-
type: pulumi.Input[str]):
|
|
328
|
+
data: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]],
|
|
329
|
+
scope: pulumi.Input[builtins.str],
|
|
330
|
+
type: pulumi.Input[builtins.str]):
|
|
330
331
|
pulumi.set(__self__, "data", data)
|
|
331
332
|
pulumi.set(__self__, "scope", scope)
|
|
332
333
|
pulumi.set(__self__, "type", type)
|
|
333
334
|
|
|
334
335
|
@property
|
|
335
336
|
@pulumi.getter
|
|
336
|
-
def data(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
337
|
+
def data(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
337
338
|
return pulumi.get(self, "data")
|
|
338
339
|
|
|
339
340
|
@data.setter
|
|
340
|
-
def data(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
341
|
+
def data(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
341
342
|
pulumi.set(self, "data", value)
|
|
342
343
|
|
|
343
344
|
@property
|
|
344
345
|
@pulumi.getter
|
|
345
|
-
def scope(self) -> pulumi.Input[str]:
|
|
346
|
+
def scope(self) -> pulumi.Input[builtins.str]:
|
|
346
347
|
return pulumi.get(self, "scope")
|
|
347
348
|
|
|
348
349
|
@scope.setter
|
|
349
|
-
def scope(self, value: pulumi.Input[str]):
|
|
350
|
+
def scope(self, value: pulumi.Input[builtins.str]):
|
|
350
351
|
pulumi.set(self, "scope", value)
|
|
351
352
|
|
|
352
353
|
@property
|
|
353
354
|
@pulumi.getter
|
|
354
|
-
def type(self) -> pulumi.Input[str]:
|
|
355
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
355
356
|
return pulumi.get(self, "type")
|
|
356
357
|
|
|
357
358
|
@type.setter
|
|
358
|
-
def type(self, value: pulumi.Input[str]):
|
|
359
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
359
360
|
pulumi.set(self, "type", value)
|
|
360
361
|
|
|
361
362
|
|
|
362
363
|
if not MYPY:
|
|
363
364
|
class DatasetRepeatArgsDict(TypedDict):
|
|
364
|
-
end_after_n: pulumi.Input[int]
|
|
365
|
-
repeats_every: pulumi.Input[str]
|
|
366
|
-
start: pulumi.Input[int]
|
|
365
|
+
end_after_n: pulumi.Input[builtins.int]
|
|
366
|
+
repeats_every: pulumi.Input[builtins.str]
|
|
367
|
+
start: pulumi.Input[builtins.int]
|
|
367
368
|
elif False:
|
|
368
369
|
DatasetRepeatArgsDict: TypeAlias = Mapping[str, Any]
|
|
369
370
|
|
|
370
371
|
@pulumi.input_type
|
|
371
372
|
class DatasetRepeatArgs:
|
|
372
373
|
def __init__(__self__, *,
|
|
373
|
-
end_after_n: pulumi.Input[int],
|
|
374
|
-
repeats_every: pulumi.Input[str],
|
|
375
|
-
start: pulumi.Input[int]):
|
|
374
|
+
end_after_n: pulumi.Input[builtins.int],
|
|
375
|
+
repeats_every: pulumi.Input[builtins.str],
|
|
376
|
+
start: pulumi.Input[builtins.int]):
|
|
376
377
|
pulumi.set(__self__, "end_after_n", end_after_n)
|
|
377
378
|
pulumi.set(__self__, "repeats_every", repeats_every)
|
|
378
379
|
pulumi.set(__self__, "start", start)
|
|
379
380
|
|
|
380
381
|
@property
|
|
381
382
|
@pulumi.getter(name="endAfterN")
|
|
382
|
-
def end_after_n(self) -> pulumi.Input[int]:
|
|
383
|
+
def end_after_n(self) -> pulumi.Input[builtins.int]:
|
|
383
384
|
return pulumi.get(self, "end_after_n")
|
|
384
385
|
|
|
385
386
|
@end_after_n.setter
|
|
386
|
-
def end_after_n(self, value: pulumi.Input[int]):
|
|
387
|
+
def end_after_n(self, value: pulumi.Input[builtins.int]):
|
|
387
388
|
pulumi.set(self, "end_after_n", value)
|
|
388
389
|
|
|
389
390
|
@property
|
|
390
391
|
@pulumi.getter(name="repeatsEvery")
|
|
391
|
-
def repeats_every(self) -> pulumi.Input[str]:
|
|
392
|
+
def repeats_every(self) -> pulumi.Input[builtins.str]:
|
|
392
393
|
return pulumi.get(self, "repeats_every")
|
|
393
394
|
|
|
394
395
|
@repeats_every.setter
|
|
395
|
-
def repeats_every(self, value: pulumi.Input[str]):
|
|
396
|
+
def repeats_every(self, value: pulumi.Input[builtins.str]):
|
|
396
397
|
pulumi.set(self, "repeats_every", value)
|
|
397
398
|
|
|
398
399
|
@property
|
|
399
400
|
@pulumi.getter
|
|
400
|
-
def start(self) -> pulumi.Input[int]:
|
|
401
|
+
def start(self) -> pulumi.Input[builtins.int]:
|
|
401
402
|
return pulumi.get(self, "start")
|
|
402
403
|
|
|
403
404
|
@start.setter
|
|
404
|
-
def start(self, value: pulumi.Input[int]):
|
|
405
|
+
def start(self, value: pulumi.Input[builtins.int]):
|
|
405
406
|
pulumi.set(self, "start", value)
|
|
406
407
|
|
|
407
408
|
|
|
408
409
|
if not MYPY:
|
|
409
410
|
class DatasetReportArgsDict(TypedDict):
|
|
410
|
-
created_at: NotRequired[pulumi.Input[int]]
|
|
411
|
-
end: NotRequired[pulumi.Input[int]]
|
|
412
|
-
id: NotRequired[pulumi.Input[str]]
|
|
413
|
-
start: NotRequired[pulumi.Input[int]]
|
|
414
|
-
status: NotRequired[pulumi.Input[str]]
|
|
411
|
+
created_at: NotRequired[pulumi.Input[builtins.int]]
|
|
412
|
+
end: NotRequired[pulumi.Input[builtins.int]]
|
|
413
|
+
id: NotRequired[pulumi.Input[builtins.str]]
|
|
414
|
+
start: NotRequired[pulumi.Input[builtins.int]]
|
|
415
|
+
status: NotRequired[pulumi.Input[builtins.str]]
|
|
415
416
|
elif False:
|
|
416
417
|
DatasetReportArgsDict: TypeAlias = Mapping[str, Any]
|
|
417
418
|
|
|
418
419
|
@pulumi.input_type
|
|
419
420
|
class DatasetReportArgs:
|
|
420
421
|
def __init__(__self__, *,
|
|
421
|
-
created_at: Optional[pulumi.Input[int]] = None,
|
|
422
|
-
end: Optional[pulumi.Input[int]] = None,
|
|
423
|
-
id: Optional[pulumi.Input[str]] = None,
|
|
424
|
-
start: Optional[pulumi.Input[int]] = None,
|
|
425
|
-
status: Optional[pulumi.Input[str]] = None):
|
|
422
|
+
created_at: Optional[pulumi.Input[builtins.int]] = None,
|
|
423
|
+
end: Optional[pulumi.Input[builtins.int]] = None,
|
|
424
|
+
id: Optional[pulumi.Input[builtins.str]] = None,
|
|
425
|
+
start: Optional[pulumi.Input[builtins.int]] = None,
|
|
426
|
+
status: Optional[pulumi.Input[builtins.str]] = None):
|
|
426
427
|
if created_at is not None:
|
|
427
428
|
pulumi.set(__self__, "created_at", created_at)
|
|
428
429
|
if end is not None:
|
|
@@ -436,66 +437,66 @@ class DatasetReportArgs:
|
|
|
436
437
|
|
|
437
438
|
@property
|
|
438
439
|
@pulumi.getter(name="createdAt")
|
|
439
|
-
def created_at(self) -> Optional[pulumi.Input[int]]:
|
|
440
|
+
def created_at(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
440
441
|
return pulumi.get(self, "created_at")
|
|
441
442
|
|
|
442
443
|
@created_at.setter
|
|
443
|
-
def created_at(self, value: Optional[pulumi.Input[int]]):
|
|
444
|
+
def created_at(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
444
445
|
pulumi.set(self, "created_at", value)
|
|
445
446
|
|
|
446
447
|
@property
|
|
447
448
|
@pulumi.getter
|
|
448
|
-
def end(self) -> Optional[pulumi.Input[int]]:
|
|
449
|
+
def end(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
449
450
|
return pulumi.get(self, "end")
|
|
450
451
|
|
|
451
452
|
@end.setter
|
|
452
|
-
def end(self, value: Optional[pulumi.Input[int]]):
|
|
453
|
+
def end(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
453
454
|
pulumi.set(self, "end", value)
|
|
454
455
|
|
|
455
456
|
@property
|
|
456
457
|
@pulumi.getter
|
|
457
|
-
def id(self) -> Optional[pulumi.Input[str]]:
|
|
458
|
+
def id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
458
459
|
return pulumi.get(self, "id")
|
|
459
460
|
|
|
460
461
|
@id.setter
|
|
461
|
-
def id(self, value: Optional[pulumi.Input[str]]):
|
|
462
|
+
def id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
462
463
|
pulumi.set(self, "id", value)
|
|
463
464
|
|
|
464
465
|
@property
|
|
465
466
|
@pulumi.getter
|
|
466
|
-
def start(self) -> Optional[pulumi.Input[int]]:
|
|
467
|
+
def start(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
467
468
|
return pulumi.get(self, "start")
|
|
468
469
|
|
|
469
470
|
@start.setter
|
|
470
|
-
def start(self, value: Optional[pulumi.Input[int]]):
|
|
471
|
+
def start(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
471
472
|
pulumi.set(self, "start", value)
|
|
472
473
|
|
|
473
474
|
@property
|
|
474
475
|
@pulumi.getter
|
|
475
|
-
def status(self) -> Optional[pulumi.Input[str]]:
|
|
476
|
+
def status(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
476
477
|
return pulumi.get(self, "status")
|
|
477
478
|
|
|
478
479
|
@status.setter
|
|
479
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
480
|
+
def status(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
480
481
|
pulumi.set(self, "status", value)
|
|
481
482
|
|
|
482
483
|
|
|
483
484
|
if not MYPY:
|
|
484
485
|
class DatasetTimeframeArgsDict(TypedDict):
|
|
485
|
-
aggregation: pulumi.Input[str]
|
|
486
|
-
cycles: NotRequired[pulumi.Input[int]]
|
|
487
|
-
from_: NotRequired[pulumi.Input[int]]
|
|
488
|
-
to: NotRequired[pulumi.Input[int]]
|
|
486
|
+
aggregation: pulumi.Input[builtins.str]
|
|
487
|
+
cycles: NotRequired[pulumi.Input[builtins.int]]
|
|
488
|
+
from_: NotRequired[pulumi.Input[builtins.int]]
|
|
489
|
+
to: NotRequired[pulumi.Input[builtins.int]]
|
|
489
490
|
elif False:
|
|
490
491
|
DatasetTimeframeArgsDict: TypeAlias = Mapping[str, Any]
|
|
491
492
|
|
|
492
493
|
@pulumi.input_type
|
|
493
494
|
class DatasetTimeframeArgs:
|
|
494
495
|
def __init__(__self__, *,
|
|
495
|
-
aggregation: pulumi.Input[str],
|
|
496
|
-
cycles: Optional[pulumi.Input[int]] = None,
|
|
497
|
-
from_: Optional[pulumi.Input[int]] = None,
|
|
498
|
-
to: Optional[pulumi.Input[int]] = None):
|
|
496
|
+
aggregation: pulumi.Input[builtins.str],
|
|
497
|
+
cycles: Optional[pulumi.Input[builtins.int]] = None,
|
|
498
|
+
from_: Optional[pulumi.Input[builtins.int]] = None,
|
|
499
|
+
to: Optional[pulumi.Input[builtins.int]] = None):
|
|
499
500
|
pulumi.set(__self__, "aggregation", aggregation)
|
|
500
501
|
if cycles is not None:
|
|
501
502
|
pulumi.set(__self__, "cycles", cycles)
|
|
@@ -506,94 +507,94 @@ class DatasetTimeframeArgs:
|
|
|
506
507
|
|
|
507
508
|
@property
|
|
508
509
|
@pulumi.getter
|
|
509
|
-
def aggregation(self) -> pulumi.Input[str]:
|
|
510
|
+
def aggregation(self) -> pulumi.Input[builtins.str]:
|
|
510
511
|
return pulumi.get(self, "aggregation")
|
|
511
512
|
|
|
512
513
|
@aggregation.setter
|
|
513
|
-
def aggregation(self, value: pulumi.Input[str]):
|
|
514
|
+
def aggregation(self, value: pulumi.Input[builtins.str]):
|
|
514
515
|
pulumi.set(self, "aggregation", value)
|
|
515
516
|
|
|
516
517
|
@property
|
|
517
518
|
@pulumi.getter
|
|
518
|
-
def cycles(self) -> Optional[pulumi.Input[int]]:
|
|
519
|
+
def cycles(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
519
520
|
return pulumi.get(self, "cycles")
|
|
520
521
|
|
|
521
522
|
@cycles.setter
|
|
522
|
-
def cycles(self, value: Optional[pulumi.Input[int]]):
|
|
523
|
+
def cycles(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
523
524
|
pulumi.set(self, "cycles", value)
|
|
524
525
|
|
|
525
526
|
@property
|
|
526
527
|
@pulumi.getter(name="from")
|
|
527
|
-
def from_(self) -> Optional[pulumi.Input[int]]:
|
|
528
|
+
def from_(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
528
529
|
return pulumi.get(self, "from_")
|
|
529
530
|
|
|
530
531
|
@from_.setter
|
|
531
|
-
def from_(self, value: Optional[pulumi.Input[int]]):
|
|
532
|
+
def from_(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
532
533
|
pulumi.set(self, "from_", value)
|
|
533
534
|
|
|
534
535
|
@property
|
|
535
536
|
@pulumi.getter
|
|
536
|
-
def to(self) -> Optional[pulumi.Input[int]]:
|
|
537
|
+
def to(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
537
538
|
return pulumi.get(self, "to")
|
|
538
539
|
|
|
539
540
|
@to.setter
|
|
540
|
-
def to(self, value: Optional[pulumi.Input[int]]):
|
|
541
|
+
def to(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
541
542
|
pulumi.set(self, "to", value)
|
|
542
543
|
|
|
543
544
|
|
|
544
545
|
if not MYPY:
|
|
545
546
|
class MonitoringJobRuleArgsDict(TypedDict):
|
|
546
|
-
comparison: pulumi.Input[str]
|
|
547
|
-
key: pulumi.Input[str]
|
|
548
|
-
value: pulumi.Input[str]
|
|
547
|
+
comparison: pulumi.Input[builtins.str]
|
|
548
|
+
key: pulumi.Input[builtins.str]
|
|
549
|
+
value: pulumi.Input[builtins.str]
|
|
549
550
|
elif False:
|
|
550
551
|
MonitoringJobRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
551
552
|
|
|
552
553
|
@pulumi.input_type
|
|
553
554
|
class MonitoringJobRuleArgs:
|
|
554
555
|
def __init__(__self__, *,
|
|
555
|
-
comparison: pulumi.Input[str],
|
|
556
|
-
key: pulumi.Input[str],
|
|
557
|
-
value: pulumi.Input[str]):
|
|
556
|
+
comparison: pulumi.Input[builtins.str],
|
|
557
|
+
key: pulumi.Input[builtins.str],
|
|
558
|
+
value: pulumi.Input[builtins.str]):
|
|
558
559
|
pulumi.set(__self__, "comparison", comparison)
|
|
559
560
|
pulumi.set(__self__, "key", key)
|
|
560
561
|
pulumi.set(__self__, "value", value)
|
|
561
562
|
|
|
562
563
|
@property
|
|
563
564
|
@pulumi.getter
|
|
564
|
-
def comparison(self) -> pulumi.Input[str]:
|
|
565
|
+
def comparison(self) -> pulumi.Input[builtins.str]:
|
|
565
566
|
return pulumi.get(self, "comparison")
|
|
566
567
|
|
|
567
568
|
@comparison.setter
|
|
568
|
-
def comparison(self, value: pulumi.Input[str]):
|
|
569
|
+
def comparison(self, value: pulumi.Input[builtins.str]):
|
|
569
570
|
pulumi.set(self, "comparison", value)
|
|
570
571
|
|
|
571
572
|
@property
|
|
572
573
|
@pulumi.getter
|
|
573
|
-
def key(self) -> pulumi.Input[str]:
|
|
574
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
574
575
|
return pulumi.get(self, "key")
|
|
575
576
|
|
|
576
577
|
@key.setter
|
|
577
|
-
def key(self, value: pulumi.Input[str]):
|
|
578
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
578
579
|
pulumi.set(self, "key", value)
|
|
579
580
|
|
|
580
581
|
@property
|
|
581
582
|
@pulumi.getter
|
|
582
|
-
def value(self) -> pulumi.Input[str]:
|
|
583
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
583
584
|
return pulumi.get(self, "value")
|
|
584
585
|
|
|
585
586
|
@value.setter
|
|
586
|
-
def value(self, value: pulumi.Input[str]):
|
|
587
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
587
588
|
pulumi.set(self, "value", value)
|
|
588
589
|
|
|
589
590
|
|
|
590
591
|
if not MYPY:
|
|
591
592
|
class NotifyListNotificationArgsDict(TypedDict):
|
|
592
|
-
config: pulumi.Input[Mapping[str, pulumi.Input[str]]]
|
|
593
|
+
config: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
|
|
593
594
|
"""
|
|
594
595
|
Configuration details for the given notifier type.
|
|
595
596
|
"""
|
|
596
|
-
type: pulumi.Input[str]
|
|
597
|
+
type: pulumi.Input[builtins.str]
|
|
597
598
|
"""
|
|
598
599
|
The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
|
|
599
600
|
"""
|
|
@@ -603,86 +604,86 @@ elif False:
|
|
|
603
604
|
@pulumi.input_type
|
|
604
605
|
class NotifyListNotificationArgs:
|
|
605
606
|
def __init__(__self__, *,
|
|
606
|
-
config: pulumi.Input[Mapping[str, pulumi.Input[str]]],
|
|
607
|
-
type: pulumi.Input[str]):
|
|
607
|
+
config: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]],
|
|
608
|
+
type: pulumi.Input[builtins.str]):
|
|
608
609
|
"""
|
|
609
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] config: Configuration details for the given notifier type.
|
|
610
|
-
:param pulumi.Input[str] type: The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
|
|
610
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] config: Configuration details for the given notifier type.
|
|
611
|
+
:param pulumi.Input[builtins.str] type: The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
|
|
611
612
|
"""
|
|
612
613
|
pulumi.set(__self__, "config", config)
|
|
613
614
|
pulumi.set(__self__, "type", type)
|
|
614
615
|
|
|
615
616
|
@property
|
|
616
617
|
@pulumi.getter
|
|
617
|
-
def config(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
|
|
618
|
+
def config(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
|
|
618
619
|
"""
|
|
619
620
|
Configuration details for the given notifier type.
|
|
620
621
|
"""
|
|
621
622
|
return pulumi.get(self, "config")
|
|
622
623
|
|
|
623
624
|
@config.setter
|
|
624
|
-
def config(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
|
|
625
|
+
def config(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
|
|
625
626
|
pulumi.set(self, "config", value)
|
|
626
627
|
|
|
627
628
|
@property
|
|
628
629
|
@pulumi.getter
|
|
629
|
-
def type(self) -> pulumi.Input[str]:
|
|
630
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
630
631
|
"""
|
|
631
632
|
The type of notifier. Available notifiers are indicated in /notifytypes endpoint.
|
|
632
633
|
"""
|
|
633
634
|
return pulumi.get(self, "type")
|
|
634
635
|
|
|
635
636
|
@type.setter
|
|
636
|
-
def type(self, value: pulumi.Input[str]):
|
|
637
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
637
638
|
pulumi.set(self, "type", value)
|
|
638
639
|
|
|
639
640
|
|
|
640
641
|
if not MYPY:
|
|
641
642
|
class PulsarJobBlendMetricWeightsArgsDict(TypedDict):
|
|
642
|
-
timestamp: pulumi.Input[int]
|
|
643
|
+
timestamp: pulumi.Input[builtins.int]
|
|
643
644
|
elif False:
|
|
644
645
|
PulsarJobBlendMetricWeightsArgsDict: TypeAlias = Mapping[str, Any]
|
|
645
646
|
|
|
646
647
|
@pulumi.input_type
|
|
647
648
|
class PulsarJobBlendMetricWeightsArgs:
|
|
648
649
|
def __init__(__self__, *,
|
|
649
|
-
timestamp: pulumi.Input[int]):
|
|
650
|
+
timestamp: pulumi.Input[builtins.int]):
|
|
650
651
|
pulumi.set(__self__, "timestamp", timestamp)
|
|
651
652
|
|
|
652
653
|
@property
|
|
653
654
|
@pulumi.getter
|
|
654
|
-
def timestamp(self) -> pulumi.Input[int]:
|
|
655
|
+
def timestamp(self) -> pulumi.Input[builtins.int]:
|
|
655
656
|
return pulumi.get(self, "timestamp")
|
|
656
657
|
|
|
657
658
|
@timestamp.setter
|
|
658
|
-
def timestamp(self, value: pulumi.Input[int]):
|
|
659
|
+
def timestamp(self, value: pulumi.Input[builtins.int]):
|
|
659
660
|
pulumi.set(self, "timestamp", value)
|
|
660
661
|
|
|
661
662
|
|
|
662
663
|
if not MYPY:
|
|
663
664
|
class PulsarJobConfigArgsDict(TypedDict):
|
|
664
|
-
host: NotRequired[pulumi.Input[str]]
|
|
665
|
-
http: NotRequired[pulumi.Input[bool]]
|
|
666
|
-
https: NotRequired[pulumi.Input[bool]]
|
|
667
|
-
job_timeout_millis: NotRequired[pulumi.Input[int]]
|
|
668
|
-
request_timeout_millis: NotRequired[pulumi.Input[int]]
|
|
669
|
-
static_values: NotRequired[pulumi.Input[bool]]
|
|
670
|
-
url_path: NotRequired[pulumi.Input[str]]
|
|
671
|
-
use_xhr: NotRequired[pulumi.Input[bool]]
|
|
665
|
+
host: NotRequired[pulumi.Input[builtins.str]]
|
|
666
|
+
http: NotRequired[pulumi.Input[builtins.bool]]
|
|
667
|
+
https: NotRequired[pulumi.Input[builtins.bool]]
|
|
668
|
+
job_timeout_millis: NotRequired[pulumi.Input[builtins.int]]
|
|
669
|
+
request_timeout_millis: NotRequired[pulumi.Input[builtins.int]]
|
|
670
|
+
static_values: NotRequired[pulumi.Input[builtins.bool]]
|
|
671
|
+
url_path: NotRequired[pulumi.Input[builtins.str]]
|
|
672
|
+
use_xhr: NotRequired[pulumi.Input[builtins.bool]]
|
|
672
673
|
elif False:
|
|
673
674
|
PulsarJobConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
674
675
|
|
|
675
676
|
@pulumi.input_type
|
|
676
677
|
class PulsarJobConfigArgs:
|
|
677
678
|
def __init__(__self__, *,
|
|
678
|
-
host: Optional[pulumi.Input[str]] = None,
|
|
679
|
-
http: Optional[pulumi.Input[bool]] = None,
|
|
680
|
-
https: Optional[pulumi.Input[bool]] = None,
|
|
681
|
-
job_timeout_millis: Optional[pulumi.Input[int]] = None,
|
|
682
|
-
request_timeout_millis: Optional[pulumi.Input[int]] = None,
|
|
683
|
-
static_values: Optional[pulumi.Input[bool]] = None,
|
|
684
|
-
url_path: Optional[pulumi.Input[str]] = None,
|
|
685
|
-
use_xhr: Optional[pulumi.Input[bool]] = None):
|
|
679
|
+
host: Optional[pulumi.Input[builtins.str]] = None,
|
|
680
|
+
http: Optional[pulumi.Input[builtins.bool]] = None,
|
|
681
|
+
https: Optional[pulumi.Input[builtins.bool]] = None,
|
|
682
|
+
job_timeout_millis: Optional[pulumi.Input[builtins.int]] = None,
|
|
683
|
+
request_timeout_millis: Optional[pulumi.Input[builtins.int]] = None,
|
|
684
|
+
static_values: Optional[pulumi.Input[builtins.bool]] = None,
|
|
685
|
+
url_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
686
|
+
use_xhr: Optional[pulumi.Input[builtins.bool]] = None):
|
|
686
687
|
if host is not None:
|
|
687
688
|
pulumi.set(__self__, "host", host)
|
|
688
689
|
if http is not None:
|
|
@@ -702,93 +703,93 @@ class PulsarJobConfigArgs:
|
|
|
702
703
|
|
|
703
704
|
@property
|
|
704
705
|
@pulumi.getter
|
|
705
|
-
def host(self) -> Optional[pulumi.Input[str]]:
|
|
706
|
+
def host(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
706
707
|
return pulumi.get(self, "host")
|
|
707
708
|
|
|
708
709
|
@host.setter
|
|
709
|
-
def host(self, value: Optional[pulumi.Input[str]]):
|
|
710
|
+
def host(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
710
711
|
pulumi.set(self, "host", value)
|
|
711
712
|
|
|
712
713
|
@property
|
|
713
714
|
@pulumi.getter
|
|
714
|
-
def http(self) -> Optional[pulumi.Input[bool]]:
|
|
715
|
+
def http(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
715
716
|
return pulumi.get(self, "http")
|
|
716
717
|
|
|
717
718
|
@http.setter
|
|
718
|
-
def http(self, value: Optional[pulumi.Input[bool]]):
|
|
719
|
+
def http(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
719
720
|
pulumi.set(self, "http", value)
|
|
720
721
|
|
|
721
722
|
@property
|
|
722
723
|
@pulumi.getter
|
|
723
|
-
def https(self) -> Optional[pulumi.Input[bool]]:
|
|
724
|
+
def https(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
724
725
|
return pulumi.get(self, "https")
|
|
725
726
|
|
|
726
727
|
@https.setter
|
|
727
|
-
def https(self, value: Optional[pulumi.Input[bool]]):
|
|
728
|
+
def https(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
728
729
|
pulumi.set(self, "https", value)
|
|
729
730
|
|
|
730
731
|
@property
|
|
731
732
|
@pulumi.getter(name="jobTimeoutMillis")
|
|
732
|
-
def job_timeout_millis(self) -> Optional[pulumi.Input[int]]:
|
|
733
|
+
def job_timeout_millis(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
733
734
|
return pulumi.get(self, "job_timeout_millis")
|
|
734
735
|
|
|
735
736
|
@job_timeout_millis.setter
|
|
736
|
-
def job_timeout_millis(self, value: Optional[pulumi.Input[int]]):
|
|
737
|
+
def job_timeout_millis(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
737
738
|
pulumi.set(self, "job_timeout_millis", value)
|
|
738
739
|
|
|
739
740
|
@property
|
|
740
741
|
@pulumi.getter(name="requestTimeoutMillis")
|
|
741
|
-
def request_timeout_millis(self) -> Optional[pulumi.Input[int]]:
|
|
742
|
+
def request_timeout_millis(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
742
743
|
return pulumi.get(self, "request_timeout_millis")
|
|
743
744
|
|
|
744
745
|
@request_timeout_millis.setter
|
|
745
|
-
def request_timeout_millis(self, value: Optional[pulumi.Input[int]]):
|
|
746
|
+
def request_timeout_millis(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
746
747
|
pulumi.set(self, "request_timeout_millis", value)
|
|
747
748
|
|
|
748
749
|
@property
|
|
749
750
|
@pulumi.getter(name="staticValues")
|
|
750
|
-
def static_values(self) -> Optional[pulumi.Input[bool]]:
|
|
751
|
+
def static_values(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
751
752
|
return pulumi.get(self, "static_values")
|
|
752
753
|
|
|
753
754
|
@static_values.setter
|
|
754
|
-
def static_values(self, value: Optional[pulumi.Input[bool]]):
|
|
755
|
+
def static_values(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
755
756
|
pulumi.set(self, "static_values", value)
|
|
756
757
|
|
|
757
758
|
@property
|
|
758
759
|
@pulumi.getter(name="urlPath")
|
|
759
|
-
def url_path(self) -> Optional[pulumi.Input[str]]:
|
|
760
|
+
def url_path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
760
761
|
return pulumi.get(self, "url_path")
|
|
761
762
|
|
|
762
763
|
@url_path.setter
|
|
763
|
-
def url_path(self, value: Optional[pulumi.Input[str]]):
|
|
764
|
+
def url_path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
764
765
|
pulumi.set(self, "url_path", value)
|
|
765
766
|
|
|
766
767
|
@property
|
|
767
768
|
@pulumi.getter(name="useXhr")
|
|
768
|
-
def use_xhr(self) -> Optional[pulumi.Input[bool]]:
|
|
769
|
+
def use_xhr(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
769
770
|
return pulumi.get(self, "use_xhr")
|
|
770
771
|
|
|
771
772
|
@use_xhr.setter
|
|
772
|
-
def use_xhr(self, value: Optional[pulumi.Input[bool]]):
|
|
773
|
+
def use_xhr(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
773
774
|
pulumi.set(self, "use_xhr", value)
|
|
774
775
|
|
|
775
776
|
|
|
776
777
|
if not MYPY:
|
|
777
778
|
class PulsarJobWeightArgsDict(TypedDict):
|
|
778
|
-
default_value: pulumi.Input[float]
|
|
779
|
-
name: pulumi.Input[str]
|
|
780
|
-
weight: pulumi.Input[int]
|
|
781
|
-
maximize: NotRequired[pulumi.Input[bool]]
|
|
779
|
+
default_value: pulumi.Input[builtins.float]
|
|
780
|
+
name: pulumi.Input[builtins.str]
|
|
781
|
+
weight: pulumi.Input[builtins.int]
|
|
782
|
+
maximize: NotRequired[pulumi.Input[builtins.bool]]
|
|
782
783
|
elif False:
|
|
783
784
|
PulsarJobWeightArgsDict: TypeAlias = Mapping[str, Any]
|
|
784
785
|
|
|
785
786
|
@pulumi.input_type
|
|
786
787
|
class PulsarJobWeightArgs:
|
|
787
788
|
def __init__(__self__, *,
|
|
788
|
-
default_value: pulumi.Input[float],
|
|
789
|
-
name: pulumi.Input[str],
|
|
790
|
-
weight: pulumi.Input[int],
|
|
791
|
-
maximize: Optional[pulumi.Input[bool]] = None):
|
|
789
|
+
default_value: pulumi.Input[builtins.float],
|
|
790
|
+
name: pulumi.Input[builtins.str],
|
|
791
|
+
weight: pulumi.Input[builtins.int],
|
|
792
|
+
maximize: Optional[pulumi.Input[builtins.bool]] = None):
|
|
792
793
|
pulumi.set(__self__, "default_value", default_value)
|
|
793
794
|
pulumi.set(__self__, "name", name)
|
|
794
795
|
pulumi.set(__self__, "weight", weight)
|
|
@@ -797,44 +798,44 @@ class PulsarJobWeightArgs:
|
|
|
797
798
|
|
|
798
799
|
@property
|
|
799
800
|
@pulumi.getter(name="defaultValue")
|
|
800
|
-
def default_value(self) -> pulumi.Input[float]:
|
|
801
|
+
def default_value(self) -> pulumi.Input[builtins.float]:
|
|
801
802
|
return pulumi.get(self, "default_value")
|
|
802
803
|
|
|
803
804
|
@default_value.setter
|
|
804
|
-
def default_value(self, value: pulumi.Input[float]):
|
|
805
|
+
def default_value(self, value: pulumi.Input[builtins.float]):
|
|
805
806
|
pulumi.set(self, "default_value", value)
|
|
806
807
|
|
|
807
808
|
@property
|
|
808
809
|
@pulumi.getter
|
|
809
|
-
def name(self) -> pulumi.Input[str]:
|
|
810
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
810
811
|
return pulumi.get(self, "name")
|
|
811
812
|
|
|
812
813
|
@name.setter
|
|
813
|
-
def name(self, value: pulumi.Input[str]):
|
|
814
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
814
815
|
pulumi.set(self, "name", value)
|
|
815
816
|
|
|
816
817
|
@property
|
|
817
818
|
@pulumi.getter
|
|
818
|
-
def weight(self) -> pulumi.Input[int]:
|
|
819
|
+
def weight(self) -> pulumi.Input[builtins.int]:
|
|
819
820
|
return pulumi.get(self, "weight")
|
|
820
821
|
|
|
821
822
|
@weight.setter
|
|
822
|
-
def weight(self, value: pulumi.Input[int]):
|
|
823
|
+
def weight(self, value: pulumi.Input[builtins.int]):
|
|
823
824
|
pulumi.set(self, "weight", value)
|
|
824
825
|
|
|
825
826
|
@property
|
|
826
827
|
@pulumi.getter
|
|
827
|
-
def maximize(self) -> Optional[pulumi.Input[bool]]:
|
|
828
|
+
def maximize(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
828
829
|
return pulumi.get(self, "maximize")
|
|
829
830
|
|
|
830
831
|
@maximize.setter
|
|
831
|
-
def maximize(self, value: Optional[pulumi.Input[bool]]):
|
|
832
|
+
def maximize(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
832
833
|
pulumi.set(self, "maximize", value)
|
|
833
834
|
|
|
834
835
|
|
|
835
836
|
if not MYPY:
|
|
836
837
|
class RecordAnswerArgsDict(TypedDict):
|
|
837
|
-
answer: NotRequired[pulumi.Input[str]]
|
|
838
|
+
answer: NotRequired[pulumi.Input[builtins.str]]
|
|
838
839
|
"""
|
|
839
840
|
Space delimited string of RDATA fields dependent on the record type.
|
|
840
841
|
|
|
@@ -858,8 +859,8 @@ if not MYPY:
|
|
|
858
859
|
|
|
859
860
|
answer = "v=DKIM1; k=rsa; p=XXXXXXXX"
|
|
860
861
|
"""
|
|
861
|
-
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
862
|
-
region: NotRequired[pulumi.Input[str]]
|
|
862
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
863
|
+
region: NotRequired[pulumi.Input[builtins.str]]
|
|
863
864
|
"""
|
|
864
865
|
The region (Answer Group really) that this answer
|
|
865
866
|
belongs to. This should be one of the names specified in `regions`. Only a
|
|
@@ -875,11 +876,11 @@ elif False:
|
|
|
875
876
|
@pulumi.input_type
|
|
876
877
|
class RecordAnswerArgs:
|
|
877
878
|
def __init__(__self__, *,
|
|
878
|
-
answer: Optional[pulumi.Input[str]] = None,
|
|
879
|
-
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
880
|
-
region: Optional[pulumi.Input[str]] = None):
|
|
879
|
+
answer: Optional[pulumi.Input[builtins.str]] = None,
|
|
880
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
881
|
+
region: Optional[pulumi.Input[builtins.str]] = None):
|
|
881
882
|
"""
|
|
882
|
-
:param pulumi.Input[str] answer: Space delimited string of RDATA fields dependent on the record type.
|
|
883
|
+
:param pulumi.Input[builtins.str] answer: Space delimited string of RDATA fields dependent on the record type.
|
|
883
884
|
|
|
884
885
|
A:
|
|
885
886
|
|
|
@@ -900,7 +901,7 @@ class RecordAnswerArgs:
|
|
|
900
901
|
SPF:
|
|
901
902
|
|
|
902
903
|
answer = "v=DKIM1; k=rsa; p=XXXXXXXX"
|
|
903
|
-
:param pulumi.Input[str] region: The region (Answer Group really) that this answer
|
|
904
|
+
:param pulumi.Input[builtins.str] region: The region (Answer Group really) that this answer
|
|
904
905
|
belongs to. This should be one of the names specified in `regions`. Only a
|
|
905
906
|
single `region` per answer is currently supported. If you want an answer in
|
|
906
907
|
multiple regions, duplicating the answer (including metadata) is the correct
|
|
@@ -917,7 +918,7 @@ class RecordAnswerArgs:
|
|
|
917
918
|
|
|
918
919
|
@property
|
|
919
920
|
@pulumi.getter
|
|
920
|
-
def answer(self) -> Optional[pulumi.Input[str]]:
|
|
921
|
+
def answer(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
921
922
|
"""
|
|
922
923
|
Space delimited string of RDATA fields dependent on the record type.
|
|
923
924
|
|
|
@@ -944,21 +945,21 @@ class RecordAnswerArgs:
|
|
|
944
945
|
return pulumi.get(self, "answer")
|
|
945
946
|
|
|
946
947
|
@answer.setter
|
|
947
|
-
def answer(self, value: Optional[pulumi.Input[str]]):
|
|
948
|
+
def answer(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
948
949
|
pulumi.set(self, "answer", value)
|
|
949
950
|
|
|
950
951
|
@property
|
|
951
952
|
@pulumi.getter
|
|
952
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
953
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
953
954
|
return pulumi.get(self, "meta")
|
|
954
955
|
|
|
955
956
|
@meta.setter
|
|
956
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
957
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
957
958
|
pulumi.set(self, "meta", value)
|
|
958
959
|
|
|
959
960
|
@property
|
|
960
961
|
@pulumi.getter
|
|
961
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
962
|
+
def region(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
962
963
|
"""
|
|
963
964
|
The region (Answer Group really) that this answer
|
|
964
965
|
belongs to. This should be one of the names specified in `regions`. Only a
|
|
@@ -971,22 +972,22 @@ class RecordAnswerArgs:
|
|
|
971
972
|
return pulumi.get(self, "region")
|
|
972
973
|
|
|
973
974
|
@region.setter
|
|
974
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
975
|
+
def region(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
975
976
|
pulumi.set(self, "region", value)
|
|
976
977
|
|
|
977
978
|
|
|
978
979
|
if not MYPY:
|
|
979
980
|
class RecordFilterArgsDict(TypedDict):
|
|
980
|
-
filter: pulumi.Input[str]
|
|
981
|
+
filter: pulumi.Input[builtins.str]
|
|
981
982
|
"""
|
|
982
983
|
The type of filter.
|
|
983
984
|
"""
|
|
984
|
-
config: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
985
|
+
config: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
985
986
|
"""
|
|
986
987
|
The filters' configuration. Simple key/value pairs
|
|
987
988
|
determined by the filter type.
|
|
988
989
|
"""
|
|
989
|
-
disabled: NotRequired[pulumi.Input[bool]]
|
|
990
|
+
disabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
990
991
|
"""
|
|
991
992
|
Determines whether the filter is applied in the
|
|
992
993
|
filter chain.
|
|
@@ -997,14 +998,14 @@ elif False:
|
|
|
997
998
|
@pulumi.input_type
|
|
998
999
|
class RecordFilterArgs:
|
|
999
1000
|
def __init__(__self__, *,
|
|
1000
|
-
filter: pulumi.Input[str],
|
|
1001
|
-
config: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1002
|
-
disabled: Optional[pulumi.Input[bool]] = None):
|
|
1001
|
+
filter: pulumi.Input[builtins.str],
|
|
1002
|
+
config: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
1003
|
+
disabled: Optional[pulumi.Input[builtins.bool]] = None):
|
|
1003
1004
|
"""
|
|
1004
|
-
:param pulumi.Input[str] filter: The type of filter.
|
|
1005
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] config: The filters' configuration. Simple key/value pairs
|
|
1005
|
+
:param pulumi.Input[builtins.str] filter: The type of filter.
|
|
1006
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] config: The filters' configuration. Simple key/value pairs
|
|
1006
1007
|
determined by the filter type.
|
|
1007
|
-
:param pulumi.Input[bool] disabled: Determines whether the filter is applied in the
|
|
1008
|
+
:param pulumi.Input[builtins.bool] disabled: Determines whether the filter is applied in the
|
|
1008
1009
|
filter chain.
|
|
1009
1010
|
"""
|
|
1010
1011
|
pulumi.set(__self__, "filter", filter)
|
|
@@ -1015,19 +1016,19 @@ class RecordFilterArgs:
|
|
|
1015
1016
|
|
|
1016
1017
|
@property
|
|
1017
1018
|
@pulumi.getter
|
|
1018
|
-
def filter(self) -> pulumi.Input[str]:
|
|
1019
|
+
def filter(self) -> pulumi.Input[builtins.str]:
|
|
1019
1020
|
"""
|
|
1020
1021
|
The type of filter.
|
|
1021
1022
|
"""
|
|
1022
1023
|
return pulumi.get(self, "filter")
|
|
1023
1024
|
|
|
1024
1025
|
@filter.setter
|
|
1025
|
-
def filter(self, value: pulumi.Input[str]):
|
|
1026
|
+
def filter(self, value: pulumi.Input[builtins.str]):
|
|
1026
1027
|
pulumi.set(self, "filter", value)
|
|
1027
1028
|
|
|
1028
1029
|
@property
|
|
1029
1030
|
@pulumi.getter
|
|
1030
|
-
def config(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1031
|
+
def config(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1031
1032
|
"""
|
|
1032
1033
|
The filters' configuration. Simple key/value pairs
|
|
1033
1034
|
determined by the filter type.
|
|
@@ -1035,12 +1036,12 @@ class RecordFilterArgs:
|
|
|
1035
1036
|
return pulumi.get(self, "config")
|
|
1036
1037
|
|
|
1037
1038
|
@config.setter
|
|
1038
|
-
def config(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1039
|
+
def config(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1039
1040
|
pulumi.set(self, "config", value)
|
|
1040
1041
|
|
|
1041
1042
|
@property
|
|
1042
1043
|
@pulumi.getter
|
|
1043
|
-
def disabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1044
|
+
def disabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1044
1045
|
"""
|
|
1045
1046
|
Determines whether the filter is applied in the
|
|
1046
1047
|
filter chain.
|
|
@@ -1048,27 +1049,27 @@ class RecordFilterArgs:
|
|
|
1048
1049
|
return pulumi.get(self, "disabled")
|
|
1049
1050
|
|
|
1050
1051
|
@disabled.setter
|
|
1051
|
-
def disabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1052
|
+
def disabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1052
1053
|
pulumi.set(self, "disabled", value)
|
|
1053
1054
|
|
|
1054
1055
|
|
|
1055
1056
|
if not MYPY:
|
|
1056
1057
|
class RecordRegionArgsDict(TypedDict):
|
|
1057
|
-
name: pulumi.Input[str]
|
|
1058
|
+
name: pulumi.Input[builtins.str]
|
|
1058
1059
|
"""
|
|
1059
1060
|
Name of the region (or Answer Group).
|
|
1060
1061
|
"""
|
|
1061
|
-
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1062
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
1062
1063
|
elif False:
|
|
1063
1064
|
RecordRegionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1064
1065
|
|
|
1065
1066
|
@pulumi.input_type
|
|
1066
1067
|
class RecordRegionArgs:
|
|
1067
1068
|
def __init__(__self__, *,
|
|
1068
|
-
name: pulumi.Input[str],
|
|
1069
|
-
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1069
|
+
name: pulumi.Input[builtins.str],
|
|
1070
|
+
meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
1070
1071
|
"""
|
|
1071
|
-
:param pulumi.Input[str] name: Name of the region (or Answer Group).
|
|
1072
|
+
:param pulumi.Input[builtins.str] name: Name of the region (or Answer Group).
|
|
1072
1073
|
"""
|
|
1073
1074
|
pulumi.set(__self__, "name", name)
|
|
1074
1075
|
if meta is not None:
|
|
@@ -1076,42 +1077,42 @@ class RecordRegionArgs:
|
|
|
1076
1077
|
|
|
1077
1078
|
@property
|
|
1078
1079
|
@pulumi.getter
|
|
1079
|
-
def name(self) -> pulumi.Input[str]:
|
|
1080
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
1080
1081
|
"""
|
|
1081
1082
|
Name of the region (or Answer Group).
|
|
1082
1083
|
"""
|
|
1083
1084
|
return pulumi.get(self, "name")
|
|
1084
1085
|
|
|
1085
1086
|
@name.setter
|
|
1086
|
-
def name(self, value: pulumi.Input[str]):
|
|
1087
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
1087
1088
|
pulumi.set(self, "name", value)
|
|
1088
1089
|
|
|
1089
1090
|
@property
|
|
1090
1091
|
@pulumi.getter
|
|
1091
|
-
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1092
|
+
def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1092
1093
|
return pulumi.get(self, "meta")
|
|
1093
1094
|
|
|
1094
1095
|
@meta.setter
|
|
1095
|
-
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1096
|
+
def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1096
1097
|
pulumi.set(self, "meta", value)
|
|
1097
1098
|
|
|
1098
1099
|
|
|
1099
1100
|
if not MYPY:
|
|
1100
1101
|
class TeamDnsRecordsAllowArgsDict(TypedDict):
|
|
1101
|
-
domain: pulumi.Input[str]
|
|
1102
|
-
include_subdomains: pulumi.Input[bool]
|
|
1103
|
-
type: pulumi.Input[str]
|
|
1104
|
-
zone: pulumi.Input[str]
|
|
1102
|
+
domain: pulumi.Input[builtins.str]
|
|
1103
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
1104
|
+
type: pulumi.Input[builtins.str]
|
|
1105
|
+
zone: pulumi.Input[builtins.str]
|
|
1105
1106
|
elif False:
|
|
1106
1107
|
TeamDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
|
|
1107
1108
|
|
|
1108
1109
|
@pulumi.input_type
|
|
1109
1110
|
class TeamDnsRecordsAllowArgs:
|
|
1110
1111
|
def __init__(__self__, *,
|
|
1111
|
-
domain: pulumi.Input[str],
|
|
1112
|
-
include_subdomains: pulumi.Input[bool],
|
|
1113
|
-
type: pulumi.Input[str],
|
|
1114
|
-
zone: pulumi.Input[str]):
|
|
1112
|
+
domain: pulumi.Input[builtins.str],
|
|
1113
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
1114
|
+
type: pulumi.Input[builtins.str],
|
|
1115
|
+
zone: pulumi.Input[builtins.str]):
|
|
1115
1116
|
pulumi.set(__self__, "domain", domain)
|
|
1116
1117
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
1117
1118
|
pulumi.set(__self__, "type", type)
|
|
@@ -1119,57 +1120,57 @@ class TeamDnsRecordsAllowArgs:
|
|
|
1119
1120
|
|
|
1120
1121
|
@property
|
|
1121
1122
|
@pulumi.getter
|
|
1122
|
-
def domain(self) -> pulumi.Input[str]:
|
|
1123
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
1123
1124
|
return pulumi.get(self, "domain")
|
|
1124
1125
|
|
|
1125
1126
|
@domain.setter
|
|
1126
|
-
def domain(self, value: pulumi.Input[str]):
|
|
1127
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
1127
1128
|
pulumi.set(self, "domain", value)
|
|
1128
1129
|
|
|
1129
1130
|
@property
|
|
1130
1131
|
@pulumi.getter(name="includeSubdomains")
|
|
1131
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
1132
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
1132
1133
|
return pulumi.get(self, "include_subdomains")
|
|
1133
1134
|
|
|
1134
1135
|
@include_subdomains.setter
|
|
1135
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
1136
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
1136
1137
|
pulumi.set(self, "include_subdomains", value)
|
|
1137
1138
|
|
|
1138
1139
|
@property
|
|
1139
1140
|
@pulumi.getter
|
|
1140
|
-
def type(self) -> pulumi.Input[str]:
|
|
1141
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
1141
1142
|
return pulumi.get(self, "type")
|
|
1142
1143
|
|
|
1143
1144
|
@type.setter
|
|
1144
|
-
def type(self, value: pulumi.Input[str]):
|
|
1145
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
1145
1146
|
pulumi.set(self, "type", value)
|
|
1146
1147
|
|
|
1147
1148
|
@property
|
|
1148
1149
|
@pulumi.getter
|
|
1149
|
-
def zone(self) -> pulumi.Input[str]:
|
|
1150
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
1150
1151
|
return pulumi.get(self, "zone")
|
|
1151
1152
|
|
|
1152
1153
|
@zone.setter
|
|
1153
|
-
def zone(self, value: pulumi.Input[str]):
|
|
1154
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
1154
1155
|
pulumi.set(self, "zone", value)
|
|
1155
1156
|
|
|
1156
1157
|
|
|
1157
1158
|
if not MYPY:
|
|
1158
1159
|
class TeamDnsRecordsDenyArgsDict(TypedDict):
|
|
1159
|
-
domain: pulumi.Input[str]
|
|
1160
|
-
include_subdomains: pulumi.Input[bool]
|
|
1161
|
-
type: pulumi.Input[str]
|
|
1162
|
-
zone: pulumi.Input[str]
|
|
1160
|
+
domain: pulumi.Input[builtins.str]
|
|
1161
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
1162
|
+
type: pulumi.Input[builtins.str]
|
|
1163
|
+
zone: pulumi.Input[builtins.str]
|
|
1163
1164
|
elif False:
|
|
1164
1165
|
TeamDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1165
1166
|
|
|
1166
1167
|
@pulumi.input_type
|
|
1167
1168
|
class TeamDnsRecordsDenyArgs:
|
|
1168
1169
|
def __init__(__self__, *,
|
|
1169
|
-
domain: pulumi.Input[str],
|
|
1170
|
-
include_subdomains: pulumi.Input[bool],
|
|
1171
|
-
type: pulumi.Input[str],
|
|
1172
|
-
zone: pulumi.Input[str]):
|
|
1170
|
+
domain: pulumi.Input[builtins.str],
|
|
1171
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
1172
|
+
type: pulumi.Input[builtins.str],
|
|
1173
|
+
zone: pulumi.Input[builtins.str]):
|
|
1173
1174
|
pulumi.set(__self__, "domain", domain)
|
|
1174
1175
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
1175
1176
|
pulumi.set(__self__, "type", type)
|
|
@@ -1177,100 +1178,100 @@ class TeamDnsRecordsDenyArgs:
|
|
|
1177
1178
|
|
|
1178
1179
|
@property
|
|
1179
1180
|
@pulumi.getter
|
|
1180
|
-
def domain(self) -> pulumi.Input[str]:
|
|
1181
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
1181
1182
|
return pulumi.get(self, "domain")
|
|
1182
1183
|
|
|
1183
1184
|
@domain.setter
|
|
1184
|
-
def domain(self, value: pulumi.Input[str]):
|
|
1185
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
1185
1186
|
pulumi.set(self, "domain", value)
|
|
1186
1187
|
|
|
1187
1188
|
@property
|
|
1188
1189
|
@pulumi.getter(name="includeSubdomains")
|
|
1189
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
1190
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
1190
1191
|
return pulumi.get(self, "include_subdomains")
|
|
1191
1192
|
|
|
1192
1193
|
@include_subdomains.setter
|
|
1193
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
1194
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
1194
1195
|
pulumi.set(self, "include_subdomains", value)
|
|
1195
1196
|
|
|
1196
1197
|
@property
|
|
1197
1198
|
@pulumi.getter
|
|
1198
|
-
def type(self) -> pulumi.Input[str]:
|
|
1199
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
1199
1200
|
return pulumi.get(self, "type")
|
|
1200
1201
|
|
|
1201
1202
|
@type.setter
|
|
1202
|
-
def type(self, value: pulumi.Input[str]):
|
|
1203
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
1203
1204
|
pulumi.set(self, "type", value)
|
|
1204
1205
|
|
|
1205
1206
|
@property
|
|
1206
1207
|
@pulumi.getter
|
|
1207
|
-
def zone(self) -> pulumi.Input[str]:
|
|
1208
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
1208
1209
|
return pulumi.get(self, "zone")
|
|
1209
1210
|
|
|
1210
1211
|
@zone.setter
|
|
1211
|
-
def zone(self, value: pulumi.Input[str]):
|
|
1212
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
1212
1213
|
pulumi.set(self, "zone", value)
|
|
1213
1214
|
|
|
1214
1215
|
|
|
1215
1216
|
if not MYPY:
|
|
1216
1217
|
class TeamIpWhitelistArgsDict(TypedDict):
|
|
1217
|
-
name: pulumi.Input[str]
|
|
1218
|
+
name: pulumi.Input[builtins.str]
|
|
1218
1219
|
"""
|
|
1219
1220
|
The free form name of the team.
|
|
1220
1221
|
"""
|
|
1221
|
-
values: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1222
|
+
values: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
1222
1223
|
elif False:
|
|
1223
1224
|
TeamIpWhitelistArgsDict: TypeAlias = Mapping[str, Any]
|
|
1224
1225
|
|
|
1225
1226
|
@pulumi.input_type
|
|
1226
1227
|
class TeamIpWhitelistArgs:
|
|
1227
1228
|
def __init__(__self__, *,
|
|
1228
|
-
name: pulumi.Input[str],
|
|
1229
|
-
values: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1229
|
+
name: pulumi.Input[builtins.str],
|
|
1230
|
+
values: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1230
1231
|
"""
|
|
1231
|
-
:param pulumi.Input[str] name: The free form name of the team.
|
|
1232
|
+
:param pulumi.Input[builtins.str] name: The free form name of the team.
|
|
1232
1233
|
"""
|
|
1233
1234
|
pulumi.set(__self__, "name", name)
|
|
1234
1235
|
pulumi.set(__self__, "values", values)
|
|
1235
1236
|
|
|
1236
1237
|
@property
|
|
1237
1238
|
@pulumi.getter
|
|
1238
|
-
def name(self) -> pulumi.Input[str]:
|
|
1239
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
1239
1240
|
"""
|
|
1240
1241
|
The free form name of the team.
|
|
1241
1242
|
"""
|
|
1242
1243
|
return pulumi.get(self, "name")
|
|
1243
1244
|
|
|
1244
1245
|
@name.setter
|
|
1245
|
-
def name(self, value: pulumi.Input[str]):
|
|
1246
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
1246
1247
|
pulumi.set(self, "name", value)
|
|
1247
1248
|
|
|
1248
1249
|
@property
|
|
1249
1250
|
@pulumi.getter
|
|
1250
|
-
def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1251
|
+
def values(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
1251
1252
|
return pulumi.get(self, "values")
|
|
1252
1253
|
|
|
1253
1254
|
@values.setter
|
|
1254
|
-
def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1255
|
+
def values(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1255
1256
|
pulumi.set(self, "values", value)
|
|
1256
1257
|
|
|
1257
1258
|
|
|
1258
1259
|
if not MYPY:
|
|
1259
1260
|
class UserDnsRecordsAllowArgsDict(TypedDict):
|
|
1260
|
-
domain: pulumi.Input[str]
|
|
1261
|
-
include_subdomains: pulumi.Input[bool]
|
|
1262
|
-
type: pulumi.Input[str]
|
|
1263
|
-
zone: pulumi.Input[str]
|
|
1261
|
+
domain: pulumi.Input[builtins.str]
|
|
1262
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
1263
|
+
type: pulumi.Input[builtins.str]
|
|
1264
|
+
zone: pulumi.Input[builtins.str]
|
|
1264
1265
|
elif False:
|
|
1265
1266
|
UserDnsRecordsAllowArgsDict: TypeAlias = Mapping[str, Any]
|
|
1266
1267
|
|
|
1267
1268
|
@pulumi.input_type
|
|
1268
1269
|
class UserDnsRecordsAllowArgs:
|
|
1269
1270
|
def __init__(__self__, *,
|
|
1270
|
-
domain: pulumi.Input[str],
|
|
1271
|
-
include_subdomains: pulumi.Input[bool],
|
|
1272
|
-
type: pulumi.Input[str],
|
|
1273
|
-
zone: pulumi.Input[str]):
|
|
1271
|
+
domain: pulumi.Input[builtins.str],
|
|
1272
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
1273
|
+
type: pulumi.Input[builtins.str],
|
|
1274
|
+
zone: pulumi.Input[builtins.str]):
|
|
1274
1275
|
pulumi.set(__self__, "domain", domain)
|
|
1275
1276
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
1276
1277
|
pulumi.set(__self__, "type", type)
|
|
@@ -1278,57 +1279,57 @@ class UserDnsRecordsAllowArgs:
|
|
|
1278
1279
|
|
|
1279
1280
|
@property
|
|
1280
1281
|
@pulumi.getter
|
|
1281
|
-
def domain(self) -> pulumi.Input[str]:
|
|
1282
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
1282
1283
|
return pulumi.get(self, "domain")
|
|
1283
1284
|
|
|
1284
1285
|
@domain.setter
|
|
1285
|
-
def domain(self, value: pulumi.Input[str]):
|
|
1286
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
1286
1287
|
pulumi.set(self, "domain", value)
|
|
1287
1288
|
|
|
1288
1289
|
@property
|
|
1289
1290
|
@pulumi.getter(name="includeSubdomains")
|
|
1290
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
1291
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
1291
1292
|
return pulumi.get(self, "include_subdomains")
|
|
1292
1293
|
|
|
1293
1294
|
@include_subdomains.setter
|
|
1294
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
1295
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
1295
1296
|
pulumi.set(self, "include_subdomains", value)
|
|
1296
1297
|
|
|
1297
1298
|
@property
|
|
1298
1299
|
@pulumi.getter
|
|
1299
|
-
def type(self) -> pulumi.Input[str]:
|
|
1300
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
1300
1301
|
return pulumi.get(self, "type")
|
|
1301
1302
|
|
|
1302
1303
|
@type.setter
|
|
1303
|
-
def type(self, value: pulumi.Input[str]):
|
|
1304
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
1304
1305
|
pulumi.set(self, "type", value)
|
|
1305
1306
|
|
|
1306
1307
|
@property
|
|
1307
1308
|
@pulumi.getter
|
|
1308
|
-
def zone(self) -> pulumi.Input[str]:
|
|
1309
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
1309
1310
|
return pulumi.get(self, "zone")
|
|
1310
1311
|
|
|
1311
1312
|
@zone.setter
|
|
1312
|
-
def zone(self, value: pulumi.Input[str]):
|
|
1313
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
1313
1314
|
pulumi.set(self, "zone", value)
|
|
1314
1315
|
|
|
1315
1316
|
|
|
1316
1317
|
if not MYPY:
|
|
1317
1318
|
class UserDnsRecordsDenyArgsDict(TypedDict):
|
|
1318
|
-
domain: pulumi.Input[str]
|
|
1319
|
-
include_subdomains: pulumi.Input[bool]
|
|
1320
|
-
type: pulumi.Input[str]
|
|
1321
|
-
zone: pulumi.Input[str]
|
|
1319
|
+
domain: pulumi.Input[builtins.str]
|
|
1320
|
+
include_subdomains: pulumi.Input[builtins.bool]
|
|
1321
|
+
type: pulumi.Input[builtins.str]
|
|
1322
|
+
zone: pulumi.Input[builtins.str]
|
|
1322
1323
|
elif False:
|
|
1323
1324
|
UserDnsRecordsDenyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1324
1325
|
|
|
1325
1326
|
@pulumi.input_type
|
|
1326
1327
|
class UserDnsRecordsDenyArgs:
|
|
1327
1328
|
def __init__(__self__, *,
|
|
1328
|
-
domain: pulumi.Input[str],
|
|
1329
|
-
include_subdomains: pulumi.Input[bool],
|
|
1330
|
-
type: pulumi.Input[str],
|
|
1331
|
-
zone: pulumi.Input[str]):
|
|
1329
|
+
domain: pulumi.Input[builtins.str],
|
|
1330
|
+
include_subdomains: pulumi.Input[builtins.bool],
|
|
1331
|
+
type: pulumi.Input[builtins.str],
|
|
1332
|
+
zone: pulumi.Input[builtins.str]):
|
|
1332
1333
|
pulumi.set(__self__, "domain", domain)
|
|
1333
1334
|
pulumi.set(__self__, "include_subdomains", include_subdomains)
|
|
1334
1335
|
pulumi.set(__self__, "type", type)
|
|
@@ -1336,59 +1337,59 @@ class UserDnsRecordsDenyArgs:
|
|
|
1336
1337
|
|
|
1337
1338
|
@property
|
|
1338
1339
|
@pulumi.getter
|
|
1339
|
-
def domain(self) -> pulumi.Input[str]:
|
|
1340
|
+
def domain(self) -> pulumi.Input[builtins.str]:
|
|
1340
1341
|
return pulumi.get(self, "domain")
|
|
1341
1342
|
|
|
1342
1343
|
@domain.setter
|
|
1343
|
-
def domain(self, value: pulumi.Input[str]):
|
|
1344
|
+
def domain(self, value: pulumi.Input[builtins.str]):
|
|
1344
1345
|
pulumi.set(self, "domain", value)
|
|
1345
1346
|
|
|
1346
1347
|
@property
|
|
1347
1348
|
@pulumi.getter(name="includeSubdomains")
|
|
1348
|
-
def include_subdomains(self) -> pulumi.Input[bool]:
|
|
1349
|
+
def include_subdomains(self) -> pulumi.Input[builtins.bool]:
|
|
1349
1350
|
return pulumi.get(self, "include_subdomains")
|
|
1350
1351
|
|
|
1351
1352
|
@include_subdomains.setter
|
|
1352
|
-
def include_subdomains(self, value: pulumi.Input[bool]):
|
|
1353
|
+
def include_subdomains(self, value: pulumi.Input[builtins.bool]):
|
|
1353
1354
|
pulumi.set(self, "include_subdomains", value)
|
|
1354
1355
|
|
|
1355
1356
|
@property
|
|
1356
1357
|
@pulumi.getter
|
|
1357
|
-
def type(self) -> pulumi.Input[str]:
|
|
1358
|
+
def type(self) -> pulumi.Input[builtins.str]:
|
|
1358
1359
|
return pulumi.get(self, "type")
|
|
1359
1360
|
|
|
1360
1361
|
@type.setter
|
|
1361
|
-
def type(self, value: pulumi.Input[str]):
|
|
1362
|
+
def type(self, value: pulumi.Input[builtins.str]):
|
|
1362
1363
|
pulumi.set(self, "type", value)
|
|
1363
1364
|
|
|
1364
1365
|
@property
|
|
1365
1366
|
@pulumi.getter
|
|
1366
|
-
def zone(self) -> pulumi.Input[str]:
|
|
1367
|
+
def zone(self) -> pulumi.Input[builtins.str]:
|
|
1367
1368
|
return pulumi.get(self, "zone")
|
|
1368
1369
|
|
|
1369
1370
|
@zone.setter
|
|
1370
|
-
def zone(self, value: pulumi.Input[str]):
|
|
1371
|
+
def zone(self, value: pulumi.Input[builtins.str]):
|
|
1371
1372
|
pulumi.set(self, "zone", value)
|
|
1372
1373
|
|
|
1373
1374
|
|
|
1374
1375
|
if not MYPY:
|
|
1375
1376
|
class ZoneSecondaryArgsDict(TypedDict):
|
|
1376
|
-
ip: pulumi.Input[str]
|
|
1377
|
+
ip: pulumi.Input[builtins.str]
|
|
1377
1378
|
"""
|
|
1378
1379
|
IPv4 address of the secondary server.
|
|
1379
1380
|
"""
|
|
1380
|
-
networks: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
1381
|
+
networks: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
|
|
1381
1382
|
"""
|
|
1382
1383
|
List of network IDs (`int`) for which the zone
|
|
1383
1384
|
should be made available. Default is network 0, the primary NSONE Global
|
|
1384
1385
|
Network. Normally, you should not have to worry about this.
|
|
1385
1386
|
"""
|
|
1386
|
-
notify: NotRequired[pulumi.Input[bool]]
|
|
1387
|
+
notify: NotRequired[pulumi.Input[builtins.bool]]
|
|
1387
1388
|
"""
|
|
1388
1389
|
Whether we send `NOTIFY` messages to the secondary host
|
|
1389
1390
|
when the zone changes. Default `false`.
|
|
1390
1391
|
"""
|
|
1391
|
-
port: NotRequired[pulumi.Input[int]]
|
|
1392
|
+
port: NotRequired[pulumi.Input[builtins.int]]
|
|
1392
1393
|
"""
|
|
1393
1394
|
Port of the the secondary server. Default `53`.
|
|
1394
1395
|
"""
|
|
@@ -1398,18 +1399,18 @@ elif False:
|
|
|
1398
1399
|
@pulumi.input_type
|
|
1399
1400
|
class ZoneSecondaryArgs:
|
|
1400
1401
|
def __init__(__self__, *,
|
|
1401
|
-
ip: pulumi.Input[str],
|
|
1402
|
-
networks: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
1403
|
-
notify: Optional[pulumi.Input[bool]] = None,
|
|
1404
|
-
port: Optional[pulumi.Input[int]] = None):
|
|
1402
|
+
ip: pulumi.Input[builtins.str],
|
|
1403
|
+
networks: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
|
|
1404
|
+
notify: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1405
|
+
port: Optional[pulumi.Input[builtins.int]] = None):
|
|
1405
1406
|
"""
|
|
1406
|
-
:param pulumi.Input[str] ip: IPv4 address of the secondary server.
|
|
1407
|
-
:param pulumi.Input[Sequence[pulumi.Input[int]]] networks: List of network IDs (`int`) for which the zone
|
|
1407
|
+
:param pulumi.Input[builtins.str] ip: IPv4 address of the secondary server.
|
|
1408
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.int]]] networks: List of network IDs (`int`) for which the zone
|
|
1408
1409
|
should be made available. Default is network 0, the primary NSONE Global
|
|
1409
1410
|
Network. Normally, you should not have to worry about this.
|
|
1410
|
-
:param pulumi.Input[bool] notify: Whether we send `NOTIFY` messages to the secondary host
|
|
1411
|
+
:param pulumi.Input[builtins.bool] notify: Whether we send `NOTIFY` messages to the secondary host
|
|
1411
1412
|
when the zone changes. Default `false`.
|
|
1412
|
-
:param pulumi.Input[int] port: Port of the the secondary server. Default `53`.
|
|
1413
|
+
:param pulumi.Input[builtins.int] port: Port of the the secondary server. Default `53`.
|
|
1413
1414
|
"""
|
|
1414
1415
|
pulumi.set(__self__, "ip", ip)
|
|
1415
1416
|
if networks is not None:
|
|
@@ -1421,19 +1422,19 @@ class ZoneSecondaryArgs:
|
|
|
1421
1422
|
|
|
1422
1423
|
@property
|
|
1423
1424
|
@pulumi.getter
|
|
1424
|
-
def ip(self) -> pulumi.Input[str]:
|
|
1425
|
+
def ip(self) -> pulumi.Input[builtins.str]:
|
|
1425
1426
|
"""
|
|
1426
1427
|
IPv4 address of the secondary server.
|
|
1427
1428
|
"""
|
|
1428
1429
|
return pulumi.get(self, "ip")
|
|
1429
1430
|
|
|
1430
1431
|
@ip.setter
|
|
1431
|
-
def ip(self, value: pulumi.Input[str]):
|
|
1432
|
+
def ip(self, value: pulumi.Input[builtins.str]):
|
|
1432
1433
|
pulumi.set(self, "ip", value)
|
|
1433
1434
|
|
|
1434
1435
|
@property
|
|
1435
1436
|
@pulumi.getter
|
|
1436
|
-
def networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
|
|
1437
|
+
def networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
|
|
1437
1438
|
"""
|
|
1438
1439
|
List of network IDs (`int`) for which the zone
|
|
1439
1440
|
should be made available. Default is network 0, the primary NSONE Global
|
|
@@ -1442,12 +1443,12 @@ class ZoneSecondaryArgs:
|
|
|
1442
1443
|
return pulumi.get(self, "networks")
|
|
1443
1444
|
|
|
1444
1445
|
@networks.setter
|
|
1445
|
-
def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
|
|
1446
|
+
def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]):
|
|
1446
1447
|
pulumi.set(self, "networks", value)
|
|
1447
1448
|
|
|
1448
1449
|
@property
|
|
1449
1450
|
@pulumi.getter
|
|
1450
|
-
def notify(self) -> Optional[pulumi.Input[bool]]:
|
|
1451
|
+
def notify(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1451
1452
|
"""
|
|
1452
1453
|
Whether we send `NOTIFY` messages to the secondary host
|
|
1453
1454
|
when the zone changes. Default `false`.
|
|
@@ -1455,33 +1456,33 @@ class ZoneSecondaryArgs:
|
|
|
1455
1456
|
return pulumi.get(self, "notify")
|
|
1456
1457
|
|
|
1457
1458
|
@notify.setter
|
|
1458
|
-
def notify(self, value: Optional[pulumi.Input[bool]]):
|
|
1459
|
+
def notify(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1459
1460
|
pulumi.set(self, "notify", value)
|
|
1460
1461
|
|
|
1461
1462
|
@property
|
|
1462
1463
|
@pulumi.getter
|
|
1463
|
-
def port(self) -> Optional[pulumi.Input[int]]:
|
|
1464
|
+
def port(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1464
1465
|
"""
|
|
1465
1466
|
Port of the the secondary server. Default `53`.
|
|
1466
1467
|
"""
|
|
1467
1468
|
return pulumi.get(self, "port")
|
|
1468
1469
|
|
|
1469
1470
|
@port.setter
|
|
1470
|
-
def port(self, value: Optional[pulumi.Input[int]]):
|
|
1471
|
+
def port(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1471
1472
|
pulumi.set(self, "port", value)
|
|
1472
1473
|
|
|
1473
1474
|
|
|
1474
1475
|
if not MYPY:
|
|
1475
1476
|
class GetMonitoringRegionsRegionArgsDict(TypedDict):
|
|
1476
|
-
code: NotRequired[str]
|
|
1477
|
+
code: NotRequired[builtins.str]
|
|
1477
1478
|
"""
|
|
1478
1479
|
3-letter city code identifying the location of the monitor.
|
|
1479
1480
|
"""
|
|
1480
|
-
name: NotRequired[str]
|
|
1481
|
+
name: NotRequired[builtins.str]
|
|
1481
1482
|
"""
|
|
1482
1483
|
City name identifying the location of the monitor.
|
|
1483
1484
|
"""
|
|
1484
|
-
subnets: NotRequired[Sequence[str]]
|
|
1485
|
+
subnets: NotRequired[Sequence[builtins.str]]
|
|
1485
1486
|
"""
|
|
1486
1487
|
A list of IPv4 and IPv6 subnets the monitor sources requests from.
|
|
1487
1488
|
"""
|
|
@@ -1491,13 +1492,13 @@ elif False:
|
|
|
1491
1492
|
@pulumi.input_type
|
|
1492
1493
|
class GetMonitoringRegionsRegionArgs:
|
|
1493
1494
|
def __init__(__self__, *,
|
|
1494
|
-
code: Optional[str] = None,
|
|
1495
|
-
name: Optional[str] = None,
|
|
1496
|
-
subnets: Optional[Sequence[str]] = None):
|
|
1495
|
+
code: Optional[builtins.str] = None,
|
|
1496
|
+
name: Optional[builtins.str] = None,
|
|
1497
|
+
subnets: Optional[Sequence[builtins.str]] = None):
|
|
1497
1498
|
"""
|
|
1498
|
-
:param str code: 3-letter city code identifying the location of the monitor.
|
|
1499
|
-
:param str name: City name identifying the location of the monitor.
|
|
1500
|
-
:param Sequence[str] subnets: A list of IPv4 and IPv6 subnets the monitor sources requests from.
|
|
1499
|
+
:param builtins.str code: 3-letter city code identifying the location of the monitor.
|
|
1500
|
+
:param builtins.str name: City name identifying the location of the monitor.
|
|
1501
|
+
:param Sequence[builtins.str] subnets: A list of IPv4 and IPv6 subnets the monitor sources requests from.
|
|
1501
1502
|
"""
|
|
1502
1503
|
if code is not None:
|
|
1503
1504
|
pulumi.set(__self__, "code", code)
|
|
@@ -1508,38 +1509,38 @@ class GetMonitoringRegionsRegionArgs:
|
|
|
1508
1509
|
|
|
1509
1510
|
@property
|
|
1510
1511
|
@pulumi.getter
|
|
1511
|
-
def code(self) -> Optional[str]:
|
|
1512
|
+
def code(self) -> Optional[builtins.str]:
|
|
1512
1513
|
"""
|
|
1513
1514
|
3-letter city code identifying the location of the monitor.
|
|
1514
1515
|
"""
|
|
1515
1516
|
return pulumi.get(self, "code")
|
|
1516
1517
|
|
|
1517
1518
|
@code.setter
|
|
1518
|
-
def code(self, value: Optional[str]):
|
|
1519
|
+
def code(self, value: Optional[builtins.str]):
|
|
1519
1520
|
pulumi.set(self, "code", value)
|
|
1520
1521
|
|
|
1521
1522
|
@property
|
|
1522
1523
|
@pulumi.getter
|
|
1523
|
-
def name(self) -> Optional[str]:
|
|
1524
|
+
def name(self) -> Optional[builtins.str]:
|
|
1524
1525
|
"""
|
|
1525
1526
|
City name identifying the location of the monitor.
|
|
1526
1527
|
"""
|
|
1527
1528
|
return pulumi.get(self, "name")
|
|
1528
1529
|
|
|
1529
1530
|
@name.setter
|
|
1530
|
-
def name(self, value: Optional[str]):
|
|
1531
|
+
def name(self, value: Optional[builtins.str]):
|
|
1531
1532
|
pulumi.set(self, "name", value)
|
|
1532
1533
|
|
|
1533
1534
|
@property
|
|
1534
1535
|
@pulumi.getter
|
|
1535
|
-
def subnets(self) -> Optional[Sequence[str]]:
|
|
1536
|
+
def subnets(self) -> Optional[Sequence[builtins.str]]:
|
|
1536
1537
|
"""
|
|
1537
1538
|
A list of IPv4 and IPv6 subnets the monitor sources requests from.
|
|
1538
1539
|
"""
|
|
1539
1540
|
return pulumi.get(self, "subnets")
|
|
1540
1541
|
|
|
1541
1542
|
@subnets.setter
|
|
1542
|
-
def subnets(self, value: Optional[Sequence[str]]):
|
|
1543
|
+
def subnets(self, value: Optional[Sequence[builtins.str]]):
|
|
1543
1544
|
pulumi.set(self, "subnets", value)
|
|
1544
1545
|
|
|
1545
1546
|
|