pulumi-ns1 3.3.0a1719035723__py3-none-any.whl → 3.3.0a1719251476__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 +18 -0
- pulumi_ns1/pulumi-plugin.json +1 -1
- pulumi_ns1/redirect.py +723 -0
- pulumi_ns1/redirect_certificate.py +231 -0
- {pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.0a1719251476.dist-info}/METADATA +1 -1
- {pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.0a1719251476.dist-info}/RECORD +8 -6
- {pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.0a1719251476.dist-info}/WHEEL +0 -0
- {pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.0a1719251476.dist-info}/top_level.txt +0 -0
pulumi_ns1/__init__.py
CHANGED
|
@@ -22,6 +22,8 @@ from .notify_list import *
|
|
|
22
22
|
from .provider import *
|
|
23
23
|
from .pulsar_job import *
|
|
24
24
|
from .record import *
|
|
25
|
+
from .redirect import *
|
|
26
|
+
from .redirect_certificate import *
|
|
25
27
|
from .subnet import *
|
|
26
28
|
from .team import *
|
|
27
29
|
from .tsigkey import *
|
|
@@ -128,6 +130,22 @@ _utilities.register(
|
|
|
128
130
|
"ns1:index/record:Record": "Record"
|
|
129
131
|
}
|
|
130
132
|
},
|
|
133
|
+
{
|
|
134
|
+
"pkg": "ns1",
|
|
135
|
+
"mod": "index/redirect",
|
|
136
|
+
"fqn": "pulumi_ns1",
|
|
137
|
+
"classes": {
|
|
138
|
+
"ns1:index/redirect:Redirect": "Redirect"
|
|
139
|
+
}
|
|
140
|
+
},
|
|
141
|
+
{
|
|
142
|
+
"pkg": "ns1",
|
|
143
|
+
"mod": "index/redirectCertificate",
|
|
144
|
+
"fqn": "pulumi_ns1",
|
|
145
|
+
"classes": {
|
|
146
|
+
"ns1:index/redirectCertificate:RedirectCertificate": "RedirectCertificate"
|
|
147
|
+
}
|
|
148
|
+
},
|
|
131
149
|
{
|
|
132
150
|
"pkg": "ns1",
|
|
133
151
|
"mod": "index/subnet",
|
pulumi_ns1/pulumi-plugin.json
CHANGED
pulumi_ns1/redirect.py
ADDED
|
@@ -0,0 +1,723 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import pulumi
|
|
8
|
+
import pulumi.runtime
|
|
9
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
10
|
+
from . import _utilities
|
|
11
|
+
|
|
12
|
+
__all__ = ['RedirectArgs', 'Redirect']
|
|
13
|
+
|
|
14
|
+
@pulumi.input_type
|
|
15
|
+
class RedirectArgs:
|
|
16
|
+
def __init__(__self__, *,
|
|
17
|
+
domain: pulumi.Input[str],
|
|
18
|
+
path: pulumi.Input[str],
|
|
19
|
+
target: pulumi.Input[str],
|
|
20
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
21
|
+
forwarding_mode: Optional[pulumi.Input[str]] = None,
|
|
22
|
+
forwarding_type: Optional[pulumi.Input[str]] = None,
|
|
23
|
+
https_forced: Optional[pulumi.Input[bool]] = None,
|
|
24
|
+
query_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
25
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
26
|
+
"""
|
|
27
|
+
The set of arguments for constructing a Redirect resource.
|
|
28
|
+
:param pulumi.Input[str] domain: The domain the redirect refers to.
|
|
29
|
+
:param pulumi.Input[str] path: The path on the domain to redirect from.
|
|
30
|
+
:param pulumi.Input[str] target: The URL to redirect to.
|
|
31
|
+
:param pulumi.Input[str] certificate_id: The certificate redirect id.
|
|
32
|
+
:param pulumi.Input[str] forwarding_mode: How the target is interpreted:
|
|
33
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
34
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
35
|
+
* __none__ does not append any part of the incoming path.
|
|
36
|
+
:param pulumi.Input[str] forwarding_type: How the redirect is executed:
|
|
37
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
38
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
39
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
40
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
41
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
42
|
+
prefer the new target page);
|
|
43
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
44
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
45
|
+
:param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
46
|
+
:param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
|
|
47
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
|
|
48
|
+
"""
|
|
49
|
+
pulumi.set(__self__, "domain", domain)
|
|
50
|
+
pulumi.set(__self__, "path", path)
|
|
51
|
+
pulumi.set(__self__, "target", target)
|
|
52
|
+
if certificate_id is not None:
|
|
53
|
+
pulumi.set(__self__, "certificate_id", certificate_id)
|
|
54
|
+
if forwarding_mode is not None:
|
|
55
|
+
pulumi.set(__self__, "forwarding_mode", forwarding_mode)
|
|
56
|
+
if forwarding_type is not None:
|
|
57
|
+
pulumi.set(__self__, "forwarding_type", forwarding_type)
|
|
58
|
+
if https_forced is not None:
|
|
59
|
+
pulumi.set(__self__, "https_forced", https_forced)
|
|
60
|
+
if query_forwarding is not None:
|
|
61
|
+
pulumi.set(__self__, "query_forwarding", query_forwarding)
|
|
62
|
+
if tags is not None:
|
|
63
|
+
pulumi.set(__self__, "tags", tags)
|
|
64
|
+
|
|
65
|
+
@property
|
|
66
|
+
@pulumi.getter
|
|
67
|
+
def domain(self) -> pulumi.Input[str]:
|
|
68
|
+
"""
|
|
69
|
+
The domain the redirect refers to.
|
|
70
|
+
"""
|
|
71
|
+
return pulumi.get(self, "domain")
|
|
72
|
+
|
|
73
|
+
@domain.setter
|
|
74
|
+
def domain(self, value: pulumi.Input[str]):
|
|
75
|
+
pulumi.set(self, "domain", value)
|
|
76
|
+
|
|
77
|
+
@property
|
|
78
|
+
@pulumi.getter
|
|
79
|
+
def path(self) -> pulumi.Input[str]:
|
|
80
|
+
"""
|
|
81
|
+
The path on the domain to redirect from.
|
|
82
|
+
"""
|
|
83
|
+
return pulumi.get(self, "path")
|
|
84
|
+
|
|
85
|
+
@path.setter
|
|
86
|
+
def path(self, value: pulumi.Input[str]):
|
|
87
|
+
pulumi.set(self, "path", value)
|
|
88
|
+
|
|
89
|
+
@property
|
|
90
|
+
@pulumi.getter
|
|
91
|
+
def target(self) -> pulumi.Input[str]:
|
|
92
|
+
"""
|
|
93
|
+
The URL to redirect to.
|
|
94
|
+
"""
|
|
95
|
+
return pulumi.get(self, "target")
|
|
96
|
+
|
|
97
|
+
@target.setter
|
|
98
|
+
def target(self, value: pulumi.Input[str]):
|
|
99
|
+
pulumi.set(self, "target", value)
|
|
100
|
+
|
|
101
|
+
@property
|
|
102
|
+
@pulumi.getter(name="certificateId")
|
|
103
|
+
def certificate_id(self) -> Optional[pulumi.Input[str]]:
|
|
104
|
+
"""
|
|
105
|
+
The certificate redirect id.
|
|
106
|
+
"""
|
|
107
|
+
return pulumi.get(self, "certificate_id")
|
|
108
|
+
|
|
109
|
+
@certificate_id.setter
|
|
110
|
+
def certificate_id(self, value: Optional[pulumi.Input[str]]):
|
|
111
|
+
pulumi.set(self, "certificate_id", value)
|
|
112
|
+
|
|
113
|
+
@property
|
|
114
|
+
@pulumi.getter(name="forwardingMode")
|
|
115
|
+
def forwarding_mode(self) -> Optional[pulumi.Input[str]]:
|
|
116
|
+
"""
|
|
117
|
+
How the target is interpreted:
|
|
118
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
119
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
120
|
+
* __none__ does not append any part of the incoming path.
|
|
121
|
+
"""
|
|
122
|
+
return pulumi.get(self, "forwarding_mode")
|
|
123
|
+
|
|
124
|
+
@forwarding_mode.setter
|
|
125
|
+
def forwarding_mode(self, value: Optional[pulumi.Input[str]]):
|
|
126
|
+
pulumi.set(self, "forwarding_mode", value)
|
|
127
|
+
|
|
128
|
+
@property
|
|
129
|
+
@pulumi.getter(name="forwardingType")
|
|
130
|
+
def forwarding_type(self) -> Optional[pulumi.Input[str]]:
|
|
131
|
+
"""
|
|
132
|
+
How the redirect is executed:
|
|
133
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
134
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
135
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
136
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
137
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
138
|
+
prefer the new target page);
|
|
139
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
140
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
141
|
+
"""
|
|
142
|
+
return pulumi.get(self, "forwarding_type")
|
|
143
|
+
|
|
144
|
+
@forwarding_type.setter
|
|
145
|
+
def forwarding_type(self, value: Optional[pulumi.Input[str]]):
|
|
146
|
+
pulumi.set(self, "forwarding_type", value)
|
|
147
|
+
|
|
148
|
+
@property
|
|
149
|
+
@pulumi.getter(name="httpsForced")
|
|
150
|
+
def https_forced(self) -> Optional[pulumi.Input[bool]]:
|
|
151
|
+
"""
|
|
152
|
+
Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
153
|
+
"""
|
|
154
|
+
return pulumi.get(self, "https_forced")
|
|
155
|
+
|
|
156
|
+
@https_forced.setter
|
|
157
|
+
def https_forced(self, value: Optional[pulumi.Input[bool]]):
|
|
158
|
+
pulumi.set(self, "https_forced", value)
|
|
159
|
+
|
|
160
|
+
@property
|
|
161
|
+
@pulumi.getter(name="queryForwarding")
|
|
162
|
+
def query_forwarding(self) -> Optional[pulumi.Input[bool]]:
|
|
163
|
+
"""
|
|
164
|
+
Enables the query string of a URL to be applied directly to the new target URL.
|
|
165
|
+
"""
|
|
166
|
+
return pulumi.get(self, "query_forwarding")
|
|
167
|
+
|
|
168
|
+
@query_forwarding.setter
|
|
169
|
+
def query_forwarding(self, value: Optional[pulumi.Input[bool]]):
|
|
170
|
+
pulumi.set(self, "query_forwarding", value)
|
|
171
|
+
|
|
172
|
+
@property
|
|
173
|
+
@pulumi.getter
|
|
174
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
175
|
+
"""
|
|
176
|
+
Tags associated with the configuration.
|
|
177
|
+
"""
|
|
178
|
+
return pulumi.get(self, "tags")
|
|
179
|
+
|
|
180
|
+
@tags.setter
|
|
181
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
182
|
+
pulumi.set(self, "tags", value)
|
|
183
|
+
|
|
184
|
+
|
|
185
|
+
@pulumi.input_type
|
|
186
|
+
class _RedirectState:
|
|
187
|
+
def __init__(__self__, *,
|
|
188
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
189
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
190
|
+
forwarding_mode: Optional[pulumi.Input[str]] = None,
|
|
191
|
+
forwarding_type: Optional[pulumi.Input[str]] = None,
|
|
192
|
+
https_enabled: Optional[pulumi.Input[bool]] = None,
|
|
193
|
+
https_forced: Optional[pulumi.Input[bool]] = None,
|
|
194
|
+
last_updated: Optional[pulumi.Input[int]] = None,
|
|
195
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
196
|
+
query_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
197
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
198
|
+
target: Optional[pulumi.Input[str]] = None):
|
|
199
|
+
"""
|
|
200
|
+
Input properties used for looking up and filtering Redirect resources.
|
|
201
|
+
:param pulumi.Input[str] certificate_id: The certificate redirect id.
|
|
202
|
+
:param pulumi.Input[str] domain: The domain the redirect refers to.
|
|
203
|
+
:param pulumi.Input[str] forwarding_mode: How the target is interpreted:
|
|
204
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
205
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
206
|
+
* __none__ does not append any part of the incoming path.
|
|
207
|
+
:param pulumi.Input[str] forwarding_type: How the redirect is executed:
|
|
208
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
209
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
210
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
211
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
212
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
213
|
+
prefer the new target page);
|
|
214
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
215
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
216
|
+
:param pulumi.Input[bool] https_enabled: True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
|
|
217
|
+
:param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
218
|
+
:param pulumi.Input[int] last_updated: The Unix timestamp representing when the certificate was last signed.
|
|
219
|
+
:param pulumi.Input[str] path: The path on the domain to redirect from.
|
|
220
|
+
:param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
|
|
221
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
|
|
222
|
+
:param pulumi.Input[str] target: The URL to redirect to.
|
|
223
|
+
"""
|
|
224
|
+
if certificate_id is not None:
|
|
225
|
+
pulumi.set(__self__, "certificate_id", certificate_id)
|
|
226
|
+
if domain is not None:
|
|
227
|
+
pulumi.set(__self__, "domain", domain)
|
|
228
|
+
if forwarding_mode is not None:
|
|
229
|
+
pulumi.set(__self__, "forwarding_mode", forwarding_mode)
|
|
230
|
+
if forwarding_type is not None:
|
|
231
|
+
pulumi.set(__self__, "forwarding_type", forwarding_type)
|
|
232
|
+
if https_enabled is not None:
|
|
233
|
+
pulumi.set(__self__, "https_enabled", https_enabled)
|
|
234
|
+
if https_forced is not None:
|
|
235
|
+
pulumi.set(__self__, "https_forced", https_forced)
|
|
236
|
+
if last_updated is not None:
|
|
237
|
+
pulumi.set(__self__, "last_updated", last_updated)
|
|
238
|
+
if path is not None:
|
|
239
|
+
pulumi.set(__self__, "path", path)
|
|
240
|
+
if query_forwarding is not None:
|
|
241
|
+
pulumi.set(__self__, "query_forwarding", query_forwarding)
|
|
242
|
+
if tags is not None:
|
|
243
|
+
pulumi.set(__self__, "tags", tags)
|
|
244
|
+
if target is not None:
|
|
245
|
+
pulumi.set(__self__, "target", target)
|
|
246
|
+
|
|
247
|
+
@property
|
|
248
|
+
@pulumi.getter(name="certificateId")
|
|
249
|
+
def certificate_id(self) -> Optional[pulumi.Input[str]]:
|
|
250
|
+
"""
|
|
251
|
+
The certificate redirect id.
|
|
252
|
+
"""
|
|
253
|
+
return pulumi.get(self, "certificate_id")
|
|
254
|
+
|
|
255
|
+
@certificate_id.setter
|
|
256
|
+
def certificate_id(self, value: Optional[pulumi.Input[str]]):
|
|
257
|
+
pulumi.set(self, "certificate_id", value)
|
|
258
|
+
|
|
259
|
+
@property
|
|
260
|
+
@pulumi.getter
|
|
261
|
+
def domain(self) -> Optional[pulumi.Input[str]]:
|
|
262
|
+
"""
|
|
263
|
+
The domain the redirect refers to.
|
|
264
|
+
"""
|
|
265
|
+
return pulumi.get(self, "domain")
|
|
266
|
+
|
|
267
|
+
@domain.setter
|
|
268
|
+
def domain(self, value: Optional[pulumi.Input[str]]):
|
|
269
|
+
pulumi.set(self, "domain", value)
|
|
270
|
+
|
|
271
|
+
@property
|
|
272
|
+
@pulumi.getter(name="forwardingMode")
|
|
273
|
+
def forwarding_mode(self) -> Optional[pulumi.Input[str]]:
|
|
274
|
+
"""
|
|
275
|
+
How the target is interpreted:
|
|
276
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
277
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
278
|
+
* __none__ does not append any part of the incoming path.
|
|
279
|
+
"""
|
|
280
|
+
return pulumi.get(self, "forwarding_mode")
|
|
281
|
+
|
|
282
|
+
@forwarding_mode.setter
|
|
283
|
+
def forwarding_mode(self, value: Optional[pulumi.Input[str]]):
|
|
284
|
+
pulumi.set(self, "forwarding_mode", value)
|
|
285
|
+
|
|
286
|
+
@property
|
|
287
|
+
@pulumi.getter(name="forwardingType")
|
|
288
|
+
def forwarding_type(self) -> Optional[pulumi.Input[str]]:
|
|
289
|
+
"""
|
|
290
|
+
How the redirect is executed:
|
|
291
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
292
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
293
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
294
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
295
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
296
|
+
prefer the new target page);
|
|
297
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
298
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
299
|
+
"""
|
|
300
|
+
return pulumi.get(self, "forwarding_type")
|
|
301
|
+
|
|
302
|
+
@forwarding_type.setter
|
|
303
|
+
def forwarding_type(self, value: Optional[pulumi.Input[str]]):
|
|
304
|
+
pulumi.set(self, "forwarding_type", value)
|
|
305
|
+
|
|
306
|
+
@property
|
|
307
|
+
@pulumi.getter(name="httpsEnabled")
|
|
308
|
+
def https_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
309
|
+
"""
|
|
310
|
+
True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
|
|
311
|
+
"""
|
|
312
|
+
return pulumi.get(self, "https_enabled")
|
|
313
|
+
|
|
314
|
+
@https_enabled.setter
|
|
315
|
+
def https_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
316
|
+
pulumi.set(self, "https_enabled", value)
|
|
317
|
+
|
|
318
|
+
@property
|
|
319
|
+
@pulumi.getter(name="httpsForced")
|
|
320
|
+
def https_forced(self) -> Optional[pulumi.Input[bool]]:
|
|
321
|
+
"""
|
|
322
|
+
Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
323
|
+
"""
|
|
324
|
+
return pulumi.get(self, "https_forced")
|
|
325
|
+
|
|
326
|
+
@https_forced.setter
|
|
327
|
+
def https_forced(self, value: Optional[pulumi.Input[bool]]):
|
|
328
|
+
pulumi.set(self, "https_forced", value)
|
|
329
|
+
|
|
330
|
+
@property
|
|
331
|
+
@pulumi.getter(name="lastUpdated")
|
|
332
|
+
def last_updated(self) -> Optional[pulumi.Input[int]]:
|
|
333
|
+
"""
|
|
334
|
+
The Unix timestamp representing when the certificate was last signed.
|
|
335
|
+
"""
|
|
336
|
+
return pulumi.get(self, "last_updated")
|
|
337
|
+
|
|
338
|
+
@last_updated.setter
|
|
339
|
+
def last_updated(self, value: Optional[pulumi.Input[int]]):
|
|
340
|
+
pulumi.set(self, "last_updated", value)
|
|
341
|
+
|
|
342
|
+
@property
|
|
343
|
+
@pulumi.getter
|
|
344
|
+
def path(self) -> Optional[pulumi.Input[str]]:
|
|
345
|
+
"""
|
|
346
|
+
The path on the domain to redirect from.
|
|
347
|
+
"""
|
|
348
|
+
return pulumi.get(self, "path")
|
|
349
|
+
|
|
350
|
+
@path.setter
|
|
351
|
+
def path(self, value: Optional[pulumi.Input[str]]):
|
|
352
|
+
pulumi.set(self, "path", value)
|
|
353
|
+
|
|
354
|
+
@property
|
|
355
|
+
@pulumi.getter(name="queryForwarding")
|
|
356
|
+
def query_forwarding(self) -> Optional[pulumi.Input[bool]]:
|
|
357
|
+
"""
|
|
358
|
+
Enables the query string of a URL to be applied directly to the new target URL.
|
|
359
|
+
"""
|
|
360
|
+
return pulumi.get(self, "query_forwarding")
|
|
361
|
+
|
|
362
|
+
@query_forwarding.setter
|
|
363
|
+
def query_forwarding(self, value: Optional[pulumi.Input[bool]]):
|
|
364
|
+
pulumi.set(self, "query_forwarding", value)
|
|
365
|
+
|
|
366
|
+
@property
|
|
367
|
+
@pulumi.getter
|
|
368
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
369
|
+
"""
|
|
370
|
+
Tags associated with the configuration.
|
|
371
|
+
"""
|
|
372
|
+
return pulumi.get(self, "tags")
|
|
373
|
+
|
|
374
|
+
@tags.setter
|
|
375
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
376
|
+
pulumi.set(self, "tags", value)
|
|
377
|
+
|
|
378
|
+
@property
|
|
379
|
+
@pulumi.getter
|
|
380
|
+
def target(self) -> Optional[pulumi.Input[str]]:
|
|
381
|
+
"""
|
|
382
|
+
The URL to redirect to.
|
|
383
|
+
"""
|
|
384
|
+
return pulumi.get(self, "target")
|
|
385
|
+
|
|
386
|
+
@target.setter
|
|
387
|
+
def target(self, value: Optional[pulumi.Input[str]]):
|
|
388
|
+
pulumi.set(self, "target", value)
|
|
389
|
+
|
|
390
|
+
|
|
391
|
+
class Redirect(pulumi.CustomResource):
|
|
392
|
+
@overload
|
|
393
|
+
def __init__(__self__,
|
|
394
|
+
resource_name: str,
|
|
395
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
396
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
397
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
398
|
+
forwarding_mode: Optional[pulumi.Input[str]] = None,
|
|
399
|
+
forwarding_type: Optional[pulumi.Input[str]] = None,
|
|
400
|
+
https_forced: Optional[pulumi.Input[bool]] = None,
|
|
401
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
402
|
+
query_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
403
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
404
|
+
target: Optional[pulumi.Input[str]] = None,
|
|
405
|
+
__props__=None):
|
|
406
|
+
"""
|
|
407
|
+
Provides a NS1 Redirect resource. This can be used to create, modify, and delete redirects.
|
|
408
|
+
|
|
409
|
+
## Example Usage
|
|
410
|
+
|
|
411
|
+
```python
|
|
412
|
+
import pulumi
|
|
413
|
+
import pulumi_ns1 as ns1
|
|
414
|
+
|
|
415
|
+
example = ns1.Redirect("example",
|
|
416
|
+
domain="www.example.com",
|
|
417
|
+
path="/from/path",
|
|
418
|
+
target="https://url.com/target/path")
|
|
419
|
+
```
|
|
420
|
+
|
|
421
|
+
### Additional Examples
|
|
422
|
+
|
|
423
|
+
```python
|
|
424
|
+
import pulumi
|
|
425
|
+
import pulumi_ns1 as ns1
|
|
426
|
+
|
|
427
|
+
example = ns1.RedirectCertificate("example", domain="www.example.com")
|
|
428
|
+
```
|
|
429
|
+
|
|
430
|
+
## NS1 Documentation
|
|
431
|
+
|
|
432
|
+
[Redirect Api Doc](https://ns1.com/api#redirect)
|
|
433
|
+
|
|
434
|
+
# ns1\\_redirect\\_certificate
|
|
435
|
+
|
|
436
|
+
Provides a NS1 Redirect Certificate resource. This can be used to create, modify, and delete redirect certificates.
|
|
437
|
+
|
|
438
|
+
## NS1 Documentation
|
|
439
|
+
|
|
440
|
+
[Redirect Api Doc](https://ns1.com/api#redirect)
|
|
441
|
+
|
|
442
|
+
:param str resource_name: The name of the resource.
|
|
443
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
444
|
+
:param pulumi.Input[str] certificate_id: The certificate redirect id.
|
|
445
|
+
:param pulumi.Input[str] domain: The domain the redirect refers to.
|
|
446
|
+
:param pulumi.Input[str] forwarding_mode: How the target is interpreted:
|
|
447
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
448
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
449
|
+
* __none__ does not append any part of the incoming path.
|
|
450
|
+
:param pulumi.Input[str] forwarding_type: How the redirect is executed:
|
|
451
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
452
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
453
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
454
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
455
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
456
|
+
prefer the new target page);
|
|
457
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
458
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
459
|
+
:param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
460
|
+
:param pulumi.Input[str] path: The path on the domain to redirect from.
|
|
461
|
+
:param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
|
|
462
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
|
|
463
|
+
:param pulumi.Input[str] target: The URL to redirect to.
|
|
464
|
+
"""
|
|
465
|
+
...
|
|
466
|
+
@overload
|
|
467
|
+
def __init__(__self__,
|
|
468
|
+
resource_name: str,
|
|
469
|
+
args: RedirectArgs,
|
|
470
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
471
|
+
"""
|
|
472
|
+
Provides a NS1 Redirect resource. This can be used to create, modify, and delete redirects.
|
|
473
|
+
|
|
474
|
+
## Example Usage
|
|
475
|
+
|
|
476
|
+
```python
|
|
477
|
+
import pulumi
|
|
478
|
+
import pulumi_ns1 as ns1
|
|
479
|
+
|
|
480
|
+
example = ns1.Redirect("example",
|
|
481
|
+
domain="www.example.com",
|
|
482
|
+
path="/from/path",
|
|
483
|
+
target="https://url.com/target/path")
|
|
484
|
+
```
|
|
485
|
+
|
|
486
|
+
### Additional Examples
|
|
487
|
+
|
|
488
|
+
```python
|
|
489
|
+
import pulumi
|
|
490
|
+
import pulumi_ns1 as ns1
|
|
491
|
+
|
|
492
|
+
example = ns1.RedirectCertificate("example", domain="www.example.com")
|
|
493
|
+
```
|
|
494
|
+
|
|
495
|
+
## NS1 Documentation
|
|
496
|
+
|
|
497
|
+
[Redirect Api Doc](https://ns1.com/api#redirect)
|
|
498
|
+
|
|
499
|
+
# ns1\\_redirect\\_certificate
|
|
500
|
+
|
|
501
|
+
Provides a NS1 Redirect Certificate resource. This can be used to create, modify, and delete redirect certificates.
|
|
502
|
+
|
|
503
|
+
## NS1 Documentation
|
|
504
|
+
|
|
505
|
+
[Redirect Api Doc](https://ns1.com/api#redirect)
|
|
506
|
+
|
|
507
|
+
:param str resource_name: The name of the resource.
|
|
508
|
+
:param RedirectArgs args: The arguments to use to populate this resource's properties.
|
|
509
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
510
|
+
"""
|
|
511
|
+
...
|
|
512
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
513
|
+
resource_args, opts = _utilities.get_resource_args_opts(RedirectArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
514
|
+
if resource_args is not None:
|
|
515
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
516
|
+
else:
|
|
517
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
518
|
+
|
|
519
|
+
def _internal_init(__self__,
|
|
520
|
+
resource_name: str,
|
|
521
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
522
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
523
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
524
|
+
forwarding_mode: Optional[pulumi.Input[str]] = None,
|
|
525
|
+
forwarding_type: Optional[pulumi.Input[str]] = None,
|
|
526
|
+
https_forced: Optional[pulumi.Input[bool]] = None,
|
|
527
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
528
|
+
query_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
529
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
530
|
+
target: Optional[pulumi.Input[str]] = None,
|
|
531
|
+
__props__=None):
|
|
532
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
533
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
534
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
535
|
+
if opts.id is None:
|
|
536
|
+
if __props__ is not None:
|
|
537
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
538
|
+
__props__ = RedirectArgs.__new__(RedirectArgs)
|
|
539
|
+
|
|
540
|
+
__props__.__dict__["certificate_id"] = certificate_id
|
|
541
|
+
if domain is None and not opts.urn:
|
|
542
|
+
raise TypeError("Missing required property 'domain'")
|
|
543
|
+
__props__.__dict__["domain"] = domain
|
|
544
|
+
__props__.__dict__["forwarding_mode"] = forwarding_mode
|
|
545
|
+
__props__.__dict__["forwarding_type"] = forwarding_type
|
|
546
|
+
__props__.__dict__["https_forced"] = https_forced
|
|
547
|
+
if path is None and not opts.urn:
|
|
548
|
+
raise TypeError("Missing required property 'path'")
|
|
549
|
+
__props__.__dict__["path"] = path
|
|
550
|
+
__props__.__dict__["query_forwarding"] = query_forwarding
|
|
551
|
+
__props__.__dict__["tags"] = tags
|
|
552
|
+
if target is None and not opts.urn:
|
|
553
|
+
raise TypeError("Missing required property 'target'")
|
|
554
|
+
__props__.__dict__["target"] = target
|
|
555
|
+
__props__.__dict__["https_enabled"] = None
|
|
556
|
+
__props__.__dict__["last_updated"] = None
|
|
557
|
+
super(Redirect, __self__).__init__(
|
|
558
|
+
'ns1:index/redirect:Redirect',
|
|
559
|
+
resource_name,
|
|
560
|
+
__props__,
|
|
561
|
+
opts)
|
|
562
|
+
|
|
563
|
+
@staticmethod
|
|
564
|
+
def get(resource_name: str,
|
|
565
|
+
id: pulumi.Input[str],
|
|
566
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
567
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
568
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
569
|
+
forwarding_mode: Optional[pulumi.Input[str]] = None,
|
|
570
|
+
forwarding_type: Optional[pulumi.Input[str]] = None,
|
|
571
|
+
https_enabled: Optional[pulumi.Input[bool]] = None,
|
|
572
|
+
https_forced: Optional[pulumi.Input[bool]] = None,
|
|
573
|
+
last_updated: Optional[pulumi.Input[int]] = None,
|
|
574
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
575
|
+
query_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
576
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
577
|
+
target: Optional[pulumi.Input[str]] = None) -> 'Redirect':
|
|
578
|
+
"""
|
|
579
|
+
Get an existing Redirect resource's state with the given name, id, and optional extra
|
|
580
|
+
properties used to qualify the lookup.
|
|
581
|
+
|
|
582
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
583
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
584
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
585
|
+
:param pulumi.Input[str] certificate_id: The certificate redirect id.
|
|
586
|
+
:param pulumi.Input[str] domain: The domain the redirect refers to.
|
|
587
|
+
:param pulumi.Input[str] forwarding_mode: How the target is interpreted:
|
|
588
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
589
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
590
|
+
* __none__ does not append any part of the incoming path.
|
|
591
|
+
:param pulumi.Input[str] forwarding_type: How the redirect is executed:
|
|
592
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
593
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
594
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
595
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
596
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
597
|
+
prefer the new target page);
|
|
598
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
599
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
600
|
+
:param pulumi.Input[bool] https_enabled: True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
|
|
601
|
+
:param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
602
|
+
:param pulumi.Input[int] last_updated: The Unix timestamp representing when the certificate was last signed.
|
|
603
|
+
:param pulumi.Input[str] path: The path on the domain to redirect from.
|
|
604
|
+
:param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
|
|
605
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
|
|
606
|
+
:param pulumi.Input[str] target: The URL to redirect to.
|
|
607
|
+
"""
|
|
608
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
609
|
+
|
|
610
|
+
__props__ = _RedirectState.__new__(_RedirectState)
|
|
611
|
+
|
|
612
|
+
__props__.__dict__["certificate_id"] = certificate_id
|
|
613
|
+
__props__.__dict__["domain"] = domain
|
|
614
|
+
__props__.__dict__["forwarding_mode"] = forwarding_mode
|
|
615
|
+
__props__.__dict__["forwarding_type"] = forwarding_type
|
|
616
|
+
__props__.__dict__["https_enabled"] = https_enabled
|
|
617
|
+
__props__.__dict__["https_forced"] = https_forced
|
|
618
|
+
__props__.__dict__["last_updated"] = last_updated
|
|
619
|
+
__props__.__dict__["path"] = path
|
|
620
|
+
__props__.__dict__["query_forwarding"] = query_forwarding
|
|
621
|
+
__props__.__dict__["tags"] = tags
|
|
622
|
+
__props__.__dict__["target"] = target
|
|
623
|
+
return Redirect(resource_name, opts=opts, __props__=__props__)
|
|
624
|
+
|
|
625
|
+
@property
|
|
626
|
+
@pulumi.getter(name="certificateId")
|
|
627
|
+
def certificate_id(self) -> pulumi.Output[str]:
|
|
628
|
+
"""
|
|
629
|
+
The certificate redirect id.
|
|
630
|
+
"""
|
|
631
|
+
return pulumi.get(self, "certificate_id")
|
|
632
|
+
|
|
633
|
+
@property
|
|
634
|
+
@pulumi.getter
|
|
635
|
+
def domain(self) -> pulumi.Output[str]:
|
|
636
|
+
"""
|
|
637
|
+
The domain the redirect refers to.
|
|
638
|
+
"""
|
|
639
|
+
return pulumi.get(self, "domain")
|
|
640
|
+
|
|
641
|
+
@property
|
|
642
|
+
@pulumi.getter(name="forwardingMode")
|
|
643
|
+
def forwarding_mode(self) -> pulumi.Output[Optional[str]]:
|
|
644
|
+
"""
|
|
645
|
+
How the target is interpreted:
|
|
646
|
+
* __all__ appends the entire incoming path to the target destination;
|
|
647
|
+
* __capture__ appends only the part of the incoming path corresponding to the wildcard (*);
|
|
648
|
+
* __none__ does not append any part of the incoming path.
|
|
649
|
+
"""
|
|
650
|
+
return pulumi.get(self, "forwarding_mode")
|
|
651
|
+
|
|
652
|
+
@property
|
|
653
|
+
@pulumi.getter(name="forwardingType")
|
|
654
|
+
def forwarding_type(self) -> pulumi.Output[Optional[str]]:
|
|
655
|
+
"""
|
|
656
|
+
How the redirect is executed:
|
|
657
|
+
* __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
|
|
658
|
+
their database and replace it with the new target page (this is recommended for SEO);
|
|
659
|
+
* __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
|
|
660
|
+
page indexed as the redirect is only temporary (while both pages might appear in the
|
|
661
|
+
search results, a temporary redirect suggests to the search engine that it should
|
|
662
|
+
prefer the new target page);
|
|
663
|
+
* __masking__ preserves the redirected domain in the browser's address bar (this lets users see the
|
|
664
|
+
address they entered, even though the displayed content comes from a different web page).
|
|
665
|
+
"""
|
|
666
|
+
return pulumi.get(self, "forwarding_type")
|
|
667
|
+
|
|
668
|
+
@property
|
|
669
|
+
@pulumi.getter(name="httpsEnabled")
|
|
670
|
+
def https_enabled(self) -> pulumi.Output[bool]:
|
|
671
|
+
"""
|
|
672
|
+
True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
|
|
673
|
+
"""
|
|
674
|
+
return pulumi.get(self, "https_enabled")
|
|
675
|
+
|
|
676
|
+
@property
|
|
677
|
+
@pulumi.getter(name="httpsForced")
|
|
678
|
+
def https_forced(self) -> pulumi.Output[bool]:
|
|
679
|
+
"""
|
|
680
|
+
Forces redirect for users that try to visit HTTP domain to HTTPS instead.
|
|
681
|
+
"""
|
|
682
|
+
return pulumi.get(self, "https_forced")
|
|
683
|
+
|
|
684
|
+
@property
|
|
685
|
+
@pulumi.getter(name="lastUpdated")
|
|
686
|
+
def last_updated(self) -> pulumi.Output[int]:
|
|
687
|
+
"""
|
|
688
|
+
The Unix timestamp representing when the certificate was last signed.
|
|
689
|
+
"""
|
|
690
|
+
return pulumi.get(self, "last_updated")
|
|
691
|
+
|
|
692
|
+
@property
|
|
693
|
+
@pulumi.getter
|
|
694
|
+
def path(self) -> pulumi.Output[str]:
|
|
695
|
+
"""
|
|
696
|
+
The path on the domain to redirect from.
|
|
697
|
+
"""
|
|
698
|
+
return pulumi.get(self, "path")
|
|
699
|
+
|
|
700
|
+
@property
|
|
701
|
+
@pulumi.getter(name="queryForwarding")
|
|
702
|
+
def query_forwarding(self) -> pulumi.Output[Optional[bool]]:
|
|
703
|
+
"""
|
|
704
|
+
Enables the query string of a URL to be applied directly to the new target URL.
|
|
705
|
+
"""
|
|
706
|
+
return pulumi.get(self, "query_forwarding")
|
|
707
|
+
|
|
708
|
+
@property
|
|
709
|
+
@pulumi.getter
|
|
710
|
+
def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
711
|
+
"""
|
|
712
|
+
Tags associated with the configuration.
|
|
713
|
+
"""
|
|
714
|
+
return pulumi.get(self, "tags")
|
|
715
|
+
|
|
716
|
+
@property
|
|
717
|
+
@pulumi.getter
|
|
718
|
+
def target(self) -> pulumi.Output[str]:
|
|
719
|
+
"""
|
|
720
|
+
The URL to redirect to.
|
|
721
|
+
"""
|
|
722
|
+
return pulumi.get(self, "target")
|
|
723
|
+
|
|
@@ -0,0 +1,231 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import pulumi
|
|
8
|
+
import pulumi.runtime
|
|
9
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
10
|
+
from . import _utilities
|
|
11
|
+
|
|
12
|
+
__all__ = ['RedirectCertificateArgs', 'RedirectCertificate']
|
|
13
|
+
|
|
14
|
+
@pulumi.input_type
|
|
15
|
+
class RedirectCertificateArgs:
|
|
16
|
+
def __init__(__self__, *,
|
|
17
|
+
domain: pulumi.Input[str]):
|
|
18
|
+
"""
|
|
19
|
+
The set of arguments for constructing a RedirectCertificate resource.
|
|
20
|
+
"""
|
|
21
|
+
pulumi.set(__self__, "domain", domain)
|
|
22
|
+
|
|
23
|
+
@property
|
|
24
|
+
@pulumi.getter
|
|
25
|
+
def domain(self) -> pulumi.Input[str]:
|
|
26
|
+
return pulumi.get(self, "domain")
|
|
27
|
+
|
|
28
|
+
@domain.setter
|
|
29
|
+
def domain(self, value: pulumi.Input[str]):
|
|
30
|
+
pulumi.set(self, "domain", value)
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
@pulumi.input_type
|
|
34
|
+
class _RedirectCertificateState:
|
|
35
|
+
def __init__(__self__, *,
|
|
36
|
+
certificate: Optional[pulumi.Input[str]] = None,
|
|
37
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
38
|
+
errors: Optional[pulumi.Input[str]] = None,
|
|
39
|
+
last_updated: Optional[pulumi.Input[int]] = None,
|
|
40
|
+
valid_from: Optional[pulumi.Input[int]] = None,
|
|
41
|
+
valid_until: Optional[pulumi.Input[int]] = None):
|
|
42
|
+
"""
|
|
43
|
+
Input properties used for looking up and filtering RedirectCertificate resources.
|
|
44
|
+
"""
|
|
45
|
+
if certificate is not None:
|
|
46
|
+
pulumi.set(__self__, "certificate", certificate)
|
|
47
|
+
if domain is not None:
|
|
48
|
+
pulumi.set(__self__, "domain", domain)
|
|
49
|
+
if errors is not None:
|
|
50
|
+
pulumi.set(__self__, "errors", errors)
|
|
51
|
+
if last_updated is not None:
|
|
52
|
+
pulumi.set(__self__, "last_updated", last_updated)
|
|
53
|
+
if valid_from is not None:
|
|
54
|
+
pulumi.set(__self__, "valid_from", valid_from)
|
|
55
|
+
if valid_until is not None:
|
|
56
|
+
pulumi.set(__self__, "valid_until", valid_until)
|
|
57
|
+
|
|
58
|
+
@property
|
|
59
|
+
@pulumi.getter
|
|
60
|
+
def certificate(self) -> Optional[pulumi.Input[str]]:
|
|
61
|
+
return pulumi.get(self, "certificate")
|
|
62
|
+
|
|
63
|
+
@certificate.setter
|
|
64
|
+
def certificate(self, value: Optional[pulumi.Input[str]]):
|
|
65
|
+
pulumi.set(self, "certificate", value)
|
|
66
|
+
|
|
67
|
+
@property
|
|
68
|
+
@pulumi.getter
|
|
69
|
+
def domain(self) -> Optional[pulumi.Input[str]]:
|
|
70
|
+
return pulumi.get(self, "domain")
|
|
71
|
+
|
|
72
|
+
@domain.setter
|
|
73
|
+
def domain(self, value: Optional[pulumi.Input[str]]):
|
|
74
|
+
pulumi.set(self, "domain", value)
|
|
75
|
+
|
|
76
|
+
@property
|
|
77
|
+
@pulumi.getter
|
|
78
|
+
def errors(self) -> Optional[pulumi.Input[str]]:
|
|
79
|
+
return pulumi.get(self, "errors")
|
|
80
|
+
|
|
81
|
+
@errors.setter
|
|
82
|
+
def errors(self, value: Optional[pulumi.Input[str]]):
|
|
83
|
+
pulumi.set(self, "errors", value)
|
|
84
|
+
|
|
85
|
+
@property
|
|
86
|
+
@pulumi.getter(name="lastUpdated")
|
|
87
|
+
def last_updated(self) -> Optional[pulumi.Input[int]]:
|
|
88
|
+
return pulumi.get(self, "last_updated")
|
|
89
|
+
|
|
90
|
+
@last_updated.setter
|
|
91
|
+
def last_updated(self, value: Optional[pulumi.Input[int]]):
|
|
92
|
+
pulumi.set(self, "last_updated", value)
|
|
93
|
+
|
|
94
|
+
@property
|
|
95
|
+
@pulumi.getter(name="validFrom")
|
|
96
|
+
def valid_from(self) -> Optional[pulumi.Input[int]]:
|
|
97
|
+
return pulumi.get(self, "valid_from")
|
|
98
|
+
|
|
99
|
+
@valid_from.setter
|
|
100
|
+
def valid_from(self, value: Optional[pulumi.Input[int]]):
|
|
101
|
+
pulumi.set(self, "valid_from", value)
|
|
102
|
+
|
|
103
|
+
@property
|
|
104
|
+
@pulumi.getter(name="validUntil")
|
|
105
|
+
def valid_until(self) -> Optional[pulumi.Input[int]]:
|
|
106
|
+
return pulumi.get(self, "valid_until")
|
|
107
|
+
|
|
108
|
+
@valid_until.setter
|
|
109
|
+
def valid_until(self, value: Optional[pulumi.Input[int]]):
|
|
110
|
+
pulumi.set(self, "valid_until", value)
|
|
111
|
+
|
|
112
|
+
|
|
113
|
+
class RedirectCertificate(pulumi.CustomResource):
|
|
114
|
+
@overload
|
|
115
|
+
def __init__(__self__,
|
|
116
|
+
resource_name: str,
|
|
117
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
118
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
119
|
+
__props__=None):
|
|
120
|
+
"""
|
|
121
|
+
Create a RedirectCertificate resource with the given unique name, props, and options.
|
|
122
|
+
:param str resource_name: The name of the resource.
|
|
123
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
124
|
+
"""
|
|
125
|
+
...
|
|
126
|
+
@overload
|
|
127
|
+
def __init__(__self__,
|
|
128
|
+
resource_name: str,
|
|
129
|
+
args: RedirectCertificateArgs,
|
|
130
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
131
|
+
"""
|
|
132
|
+
Create a RedirectCertificate resource with the given unique name, props, and options.
|
|
133
|
+
:param str resource_name: The name of the resource.
|
|
134
|
+
:param RedirectCertificateArgs args: The arguments to use to populate this resource's properties.
|
|
135
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
136
|
+
"""
|
|
137
|
+
...
|
|
138
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
139
|
+
resource_args, opts = _utilities.get_resource_args_opts(RedirectCertificateArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
140
|
+
if resource_args is not None:
|
|
141
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
142
|
+
else:
|
|
143
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
144
|
+
|
|
145
|
+
def _internal_init(__self__,
|
|
146
|
+
resource_name: str,
|
|
147
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
148
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
149
|
+
__props__=None):
|
|
150
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
151
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
152
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
153
|
+
if opts.id is None:
|
|
154
|
+
if __props__ is not None:
|
|
155
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
156
|
+
__props__ = RedirectCertificateArgs.__new__(RedirectCertificateArgs)
|
|
157
|
+
|
|
158
|
+
if domain is None and not opts.urn:
|
|
159
|
+
raise TypeError("Missing required property 'domain'")
|
|
160
|
+
__props__.__dict__["domain"] = domain
|
|
161
|
+
__props__.__dict__["certificate"] = None
|
|
162
|
+
__props__.__dict__["errors"] = None
|
|
163
|
+
__props__.__dict__["last_updated"] = None
|
|
164
|
+
__props__.__dict__["valid_from"] = None
|
|
165
|
+
__props__.__dict__["valid_until"] = None
|
|
166
|
+
super(RedirectCertificate, __self__).__init__(
|
|
167
|
+
'ns1:index/redirectCertificate:RedirectCertificate',
|
|
168
|
+
resource_name,
|
|
169
|
+
__props__,
|
|
170
|
+
opts)
|
|
171
|
+
|
|
172
|
+
@staticmethod
|
|
173
|
+
def get(resource_name: str,
|
|
174
|
+
id: pulumi.Input[str],
|
|
175
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
176
|
+
certificate: Optional[pulumi.Input[str]] = None,
|
|
177
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
178
|
+
errors: Optional[pulumi.Input[str]] = None,
|
|
179
|
+
last_updated: Optional[pulumi.Input[int]] = None,
|
|
180
|
+
valid_from: Optional[pulumi.Input[int]] = None,
|
|
181
|
+
valid_until: Optional[pulumi.Input[int]] = None) -> 'RedirectCertificate':
|
|
182
|
+
"""
|
|
183
|
+
Get an existing RedirectCertificate resource's state with the given name, id, and optional extra
|
|
184
|
+
properties used to qualify the lookup.
|
|
185
|
+
|
|
186
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
187
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
188
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
189
|
+
"""
|
|
190
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
191
|
+
|
|
192
|
+
__props__ = _RedirectCertificateState.__new__(_RedirectCertificateState)
|
|
193
|
+
|
|
194
|
+
__props__.__dict__["certificate"] = certificate
|
|
195
|
+
__props__.__dict__["domain"] = domain
|
|
196
|
+
__props__.__dict__["errors"] = errors
|
|
197
|
+
__props__.__dict__["last_updated"] = last_updated
|
|
198
|
+
__props__.__dict__["valid_from"] = valid_from
|
|
199
|
+
__props__.__dict__["valid_until"] = valid_until
|
|
200
|
+
return RedirectCertificate(resource_name, opts=opts, __props__=__props__)
|
|
201
|
+
|
|
202
|
+
@property
|
|
203
|
+
@pulumi.getter
|
|
204
|
+
def certificate(self) -> pulumi.Output[str]:
|
|
205
|
+
return pulumi.get(self, "certificate")
|
|
206
|
+
|
|
207
|
+
@property
|
|
208
|
+
@pulumi.getter
|
|
209
|
+
def domain(self) -> pulumi.Output[str]:
|
|
210
|
+
return pulumi.get(self, "domain")
|
|
211
|
+
|
|
212
|
+
@property
|
|
213
|
+
@pulumi.getter
|
|
214
|
+
def errors(self) -> pulumi.Output[str]:
|
|
215
|
+
return pulumi.get(self, "errors")
|
|
216
|
+
|
|
217
|
+
@property
|
|
218
|
+
@pulumi.getter(name="lastUpdated")
|
|
219
|
+
def last_updated(self) -> pulumi.Output[int]:
|
|
220
|
+
return pulumi.get(self, "last_updated")
|
|
221
|
+
|
|
222
|
+
@property
|
|
223
|
+
@pulumi.getter(name="validFrom")
|
|
224
|
+
def valid_from(self) -> pulumi.Output[int]:
|
|
225
|
+
return pulumi.get(self, "valid_from")
|
|
226
|
+
|
|
227
|
+
@property
|
|
228
|
+
@pulumi.getter(name="validUntil")
|
|
229
|
+
def valid_until(self) -> pulumi.Output[int]:
|
|
230
|
+
return pulumi.get(self, "valid_until")
|
|
231
|
+
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
pulumi_ns1/__init__.py,sha256=
|
|
1
|
+
pulumi_ns1/__init__.py,sha256=_t-RU0JWspVvqo3Sl3ADYZ1Lf7P6fHSGIt5iUaoeShU,3816
|
|
2
2
|
pulumi_ns1/_inputs.py,sha256=8FSj_cd_yoTCKSpENO84hL6nUYMk5nV4TMPiVfmKCLE,38901
|
|
3
3
|
pulumi_ns1/_utilities.py,sha256=b6gJn0IIeM1t6Q7EVjqw3yhuGyP-uENQhtL5yp7aHR8,9248
|
|
4
4
|
pulumi_ns1/account_whitelist.py,sha256=rTZ7XcM7jO4iB0g7Q4bC0WEY26ysnEY3qXG77q-QpDI,9054
|
|
@@ -18,9 +18,11 @@ pulumi_ns1/notify_list.py,sha256=w4Z350jOCgGwAUKwgWTa502Xx_8EK4o_BsJj-HoXL2A,110
|
|
|
18
18
|
pulumi_ns1/outputs.py,sha256=Ld_6Lm9hRElF10c_aIewKwbtmsXIJzlZXXI4OqUHt0o,46058
|
|
19
19
|
pulumi_ns1/provider.py,sha256=5E3JbCjCD3ztCf3HFRYQ_c680oYir0a9h_Fy3nUtHe0,10590
|
|
20
20
|
pulumi_ns1/pulsar_job.py,sha256=Gk12BJdVCy6QWEqt99Wf5RqvZXEIf8Oub5Qn0x3YfjM,17050
|
|
21
|
-
pulumi_ns1/pulumi-plugin.json,sha256=
|
|
21
|
+
pulumi_ns1/pulumi-plugin.json,sha256=RlRqN9rvIPyfKN2pIAv4zQXetYiVZ_Tk6Yckvh1IspM,79
|
|
22
22
|
pulumi_ns1/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
23
23
|
pulumi_ns1/record.py,sha256=7W76cCpzqzdOvV10g3HDh_4l-YlVameA2rBmeZ9HXGE,45469
|
|
24
|
+
pulumi_ns1/redirect.py,sha256=KpClbfRDOD-dPpJc3enWi9JswvelRw59iiOlw0ZWFbM,32828
|
|
25
|
+
pulumi_ns1/redirect_certificate.py,sha256=oEPHvmHoioIevrzNoyqGLpDAlDyjMeQqqsQYwRx-IGI,8886
|
|
24
26
|
pulumi_ns1/subnet.py,sha256=9LN3o8gVwCgL4hC9wwFDzU4WPNXDxCOZE3MudBWPlq0,19239
|
|
25
27
|
pulumi_ns1/team.py,sha256=W7zln_uUxGUhRLpwygcW0hmPwUAJmV9dtJXNgPmaFT0,81714
|
|
26
28
|
pulumi_ns1/tsigkey.py,sha256=HpbUG1x720Ix-BuA-qj5MIurFDVQ2JI_Y2b736cN97E,10038
|
|
@@ -29,7 +31,7 @@ pulumi_ns1/zone.py,sha256=easSfXfDqQhz6tNwc7SGCK5CdwTlq340VTByde69tqI,43790
|
|
|
29
31
|
pulumi_ns1/config/__init__.py,sha256=cfY0smRZD3fDVc93ZIAxEl_IM2pynmXB52n3Ahzi030,285
|
|
30
32
|
pulumi_ns1/config/__init__.pyi,sha256=gTM1utkGS4KH3on5zyhR_a6AtTg4_jVpEXyQeU7ZpJQ,865
|
|
31
33
|
pulumi_ns1/config/vars.py,sha256=bQTOWrwMP1x58zYPNlK8g8CTAbOUMF3GyfcevML1frE,1674
|
|
32
|
-
pulumi_ns1-3.3.
|
|
33
|
-
pulumi_ns1-3.3.
|
|
34
|
-
pulumi_ns1-3.3.
|
|
35
|
-
pulumi_ns1-3.3.
|
|
34
|
+
pulumi_ns1-3.3.0a1719251476.dist-info/METADATA,sha256=0Sd6IkT1lZ3-WqwbGV8mQnevXn3QtKbfXZvMW9UbLRg,3047
|
|
35
|
+
pulumi_ns1-3.3.0a1719251476.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
|
|
36
|
+
pulumi_ns1-3.3.0a1719251476.dist-info/top_level.txt,sha256=Sndx9N4MHnSbjpwVT-_JZ8NZ7JzudJUIUQkU2-9GH9U,11
|
|
37
|
+
pulumi_ns1-3.3.0a1719251476.dist-info/RECORD,,
|
|
File without changes
|
{pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.0a1719251476.dist-info}/top_level.txt
RENAMED
|
File without changes
|