pulumi-mailgun 3.6.0a1710156895__py3-none-any.whl → 3.6.0a1736849423__py3-none-any.whl
Sign up to get free protection for your applications and to get access to all the features.
- pulumi_mailgun/_inputs.py +99 -0
- pulumi_mailgun/_utilities.py +41 -5
- pulumi_mailgun/config/__init__.pyi +5 -0
- pulumi_mailgun/config/vars.py +5 -0
- pulumi_mailgun/domain.py +117 -28
- pulumi_mailgun/domain_credential.py +33 -0
- pulumi_mailgun/get_domain.py +100 -34
- pulumi_mailgun/outputs.py +5 -0
- pulumi_mailgun/provider.py +5 -0
- pulumi_mailgun/pulumi-plugin.json +2 -1
- pulumi_mailgun/route.py +13 -12
- pulumi_mailgun/webhook.py +14 -13
- {pulumi_mailgun-3.6.0a1710156895.dist-info → pulumi_mailgun-3.6.0a1736849423.dist-info}/METADATA +7 -6
- pulumi_mailgun-3.6.0a1736849423.dist-info/RECORD +19 -0
- {pulumi_mailgun-3.6.0a1710156895.dist-info → pulumi_mailgun-3.6.0a1736849423.dist-info}/WHEEL +1 -1
- pulumi_mailgun-3.6.0a1710156895.dist-info/RECORD +0 -19
- {pulumi_mailgun-3.6.0a1710156895.dist-info → pulumi_mailgun-3.6.0a1736849423.dist-info}/top_level.txt +0 -0
pulumi_mailgun/_inputs.py
CHANGED
|
@@ -4,18 +4,51 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
|
|
12
17
|
__all__ = [
|
|
13
18
|
'DomainReceivingRecordArgs',
|
|
19
|
+
'DomainReceivingRecordArgsDict',
|
|
14
20
|
'DomainReceivingRecordsSetArgs',
|
|
21
|
+
'DomainReceivingRecordsSetArgsDict',
|
|
15
22
|
'DomainSendingRecordArgs',
|
|
23
|
+
'DomainSendingRecordArgsDict',
|
|
16
24
|
'DomainSendingRecordsSetArgs',
|
|
25
|
+
'DomainSendingRecordsSetArgsDict',
|
|
17
26
|
]
|
|
18
27
|
|
|
28
|
+
MYPY = False
|
|
29
|
+
|
|
30
|
+
if not MYPY:
|
|
31
|
+
class DomainReceivingRecordArgsDict(TypedDict):
|
|
32
|
+
id: NotRequired[pulumi.Input[str]]
|
|
33
|
+
priority: NotRequired[pulumi.Input[str]]
|
|
34
|
+
"""
|
|
35
|
+
The priority of the record.
|
|
36
|
+
"""
|
|
37
|
+
record_type: NotRequired[pulumi.Input[str]]
|
|
38
|
+
"""
|
|
39
|
+
The record type.
|
|
40
|
+
"""
|
|
41
|
+
valid: NotRequired[pulumi.Input[str]]
|
|
42
|
+
"""
|
|
43
|
+
`"valid"` if the record is valid.
|
|
44
|
+
"""
|
|
45
|
+
value: NotRequired[pulumi.Input[str]]
|
|
46
|
+
"""
|
|
47
|
+
The value of the record.
|
|
48
|
+
"""
|
|
49
|
+
elif False:
|
|
50
|
+
DomainReceivingRecordArgsDict: TypeAlias = Mapping[str, Any]
|
|
51
|
+
|
|
19
52
|
@pulumi.input_type
|
|
20
53
|
class DomainReceivingRecordArgs:
|
|
21
54
|
def __init__(__self__, *,
|
|
@@ -99,6 +132,28 @@ class DomainReceivingRecordArgs:
|
|
|
99
132
|
pulumi.set(self, "value", value)
|
|
100
133
|
|
|
101
134
|
|
|
135
|
+
if not MYPY:
|
|
136
|
+
class DomainReceivingRecordsSetArgsDict(TypedDict):
|
|
137
|
+
id: NotRequired[pulumi.Input[str]]
|
|
138
|
+
priority: NotRequired[pulumi.Input[str]]
|
|
139
|
+
"""
|
|
140
|
+
The priority of the record.
|
|
141
|
+
"""
|
|
142
|
+
record_type: NotRequired[pulumi.Input[str]]
|
|
143
|
+
"""
|
|
144
|
+
The record type.
|
|
145
|
+
"""
|
|
146
|
+
valid: NotRequired[pulumi.Input[str]]
|
|
147
|
+
"""
|
|
148
|
+
`"valid"` if the record is valid.
|
|
149
|
+
"""
|
|
150
|
+
value: NotRequired[pulumi.Input[str]]
|
|
151
|
+
"""
|
|
152
|
+
The value of the record.
|
|
153
|
+
"""
|
|
154
|
+
elif False:
|
|
155
|
+
DomainReceivingRecordsSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
156
|
+
|
|
102
157
|
@pulumi.input_type
|
|
103
158
|
class DomainReceivingRecordsSetArgs:
|
|
104
159
|
def __init__(__self__, *,
|
|
@@ -182,6 +237,28 @@ class DomainReceivingRecordsSetArgs:
|
|
|
182
237
|
pulumi.set(self, "value", value)
|
|
183
238
|
|
|
184
239
|
|
|
240
|
+
if not MYPY:
|
|
241
|
+
class DomainSendingRecordArgsDict(TypedDict):
|
|
242
|
+
id: NotRequired[pulumi.Input[str]]
|
|
243
|
+
name: NotRequired[pulumi.Input[str]]
|
|
244
|
+
"""
|
|
245
|
+
The domain to add to Mailgun
|
|
246
|
+
"""
|
|
247
|
+
record_type: NotRequired[pulumi.Input[str]]
|
|
248
|
+
"""
|
|
249
|
+
The record type.
|
|
250
|
+
"""
|
|
251
|
+
valid: NotRequired[pulumi.Input[str]]
|
|
252
|
+
"""
|
|
253
|
+
`"valid"` if the record is valid.
|
|
254
|
+
"""
|
|
255
|
+
value: NotRequired[pulumi.Input[str]]
|
|
256
|
+
"""
|
|
257
|
+
The value of the record.
|
|
258
|
+
"""
|
|
259
|
+
elif False:
|
|
260
|
+
DomainSendingRecordArgsDict: TypeAlias = Mapping[str, Any]
|
|
261
|
+
|
|
185
262
|
@pulumi.input_type
|
|
186
263
|
class DomainSendingRecordArgs:
|
|
187
264
|
def __init__(__self__, *,
|
|
@@ -265,6 +342,28 @@ class DomainSendingRecordArgs:
|
|
|
265
342
|
pulumi.set(self, "value", value)
|
|
266
343
|
|
|
267
344
|
|
|
345
|
+
if not MYPY:
|
|
346
|
+
class DomainSendingRecordsSetArgsDict(TypedDict):
|
|
347
|
+
id: NotRequired[pulumi.Input[str]]
|
|
348
|
+
name: NotRequired[pulumi.Input[str]]
|
|
349
|
+
"""
|
|
350
|
+
The domain to add to Mailgun
|
|
351
|
+
"""
|
|
352
|
+
record_type: NotRequired[pulumi.Input[str]]
|
|
353
|
+
"""
|
|
354
|
+
The record type.
|
|
355
|
+
"""
|
|
356
|
+
valid: NotRequired[pulumi.Input[str]]
|
|
357
|
+
"""
|
|
358
|
+
`"valid"` if the record is valid.
|
|
359
|
+
"""
|
|
360
|
+
value: NotRequired[pulumi.Input[str]]
|
|
361
|
+
"""
|
|
362
|
+
The value of the record.
|
|
363
|
+
"""
|
|
364
|
+
elif False:
|
|
365
|
+
DomainSendingRecordsSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
366
|
+
|
|
268
367
|
@pulumi.input_type
|
|
269
368
|
class DomainSendingRecordsSetArgs:
|
|
270
369
|
def __init__(__self__, *,
|
pulumi_mailgun/_utilities.py
CHANGED
|
@@ -4,6 +4,7 @@
|
|
|
4
4
|
|
|
5
5
|
|
|
6
6
|
import asyncio
|
|
7
|
+
import functools
|
|
7
8
|
import importlib.metadata
|
|
8
9
|
import importlib.util
|
|
9
10
|
import inspect
|
|
@@ -11,14 +12,19 @@ import json
|
|
|
11
12
|
import os
|
|
12
13
|
import sys
|
|
13
14
|
import typing
|
|
15
|
+
import warnings
|
|
16
|
+
import base64
|
|
14
17
|
|
|
15
18
|
import pulumi
|
|
16
19
|
import pulumi.runtime
|
|
17
20
|
from pulumi.runtime.sync_await import _sync_await
|
|
21
|
+
from pulumi.runtime.proto import resource_pb2
|
|
18
22
|
|
|
19
23
|
from semver import VersionInfo as SemverVersion
|
|
20
24
|
from parver import Version as PEP440Version
|
|
21
25
|
|
|
26
|
+
C = typing.TypeVar("C", bound=typing.Callable)
|
|
27
|
+
|
|
22
28
|
|
|
23
29
|
def get_env(*args):
|
|
24
30
|
for v in args:
|
|
@@ -96,10 +102,6 @@ def _get_semver_version():
|
|
|
96
102
|
_version = _get_semver_version()
|
|
97
103
|
_version_str = str(_version)
|
|
98
104
|
|
|
99
|
-
|
|
100
|
-
def get_version():
|
|
101
|
-
return _version_str
|
|
102
|
-
|
|
103
105
|
def get_resource_opts_defaults() -> pulumi.ResourceOptions:
|
|
104
106
|
return pulumi.ResourceOptions(
|
|
105
107
|
version=get_version(),
|
|
@@ -262,7 +264,7 @@ def call_plain(
|
|
|
262
264
|
output = pulumi.runtime.call(tok, props, res, typ)
|
|
263
265
|
|
|
264
266
|
# Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency.
|
|
265
|
-
result, known, secret, _ = _sync_await(asyncio.
|
|
267
|
+
result, known, secret, _ = _sync_await(asyncio.create_task(_await_output(output)))
|
|
266
268
|
|
|
267
269
|
problem = None
|
|
268
270
|
if not known:
|
|
@@ -287,5 +289,39 @@ async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bo
|
|
|
287
289
|
await o._resources,
|
|
288
290
|
)
|
|
289
291
|
|
|
292
|
+
|
|
293
|
+
# This is included to provide an upgrade path for users who are using a version
|
|
294
|
+
# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator.
|
|
295
|
+
def deprecated(message: str) -> typing.Callable[[C], C]:
|
|
296
|
+
"""
|
|
297
|
+
Decorator to indicate a function is deprecated.
|
|
298
|
+
|
|
299
|
+
As well as inserting appropriate statements to indicate that the function is
|
|
300
|
+
deprecated, this decorator also tags the function with a special attribute
|
|
301
|
+
so that Pulumi code can detect that it is deprecated and react appropriately
|
|
302
|
+
in certain situations.
|
|
303
|
+
|
|
304
|
+
message is the deprecation message that should be printed if the function is called.
|
|
305
|
+
"""
|
|
306
|
+
|
|
307
|
+
def decorator(fn: C) -> C:
|
|
308
|
+
if not callable(fn):
|
|
309
|
+
raise TypeError("Expected fn to be callable")
|
|
310
|
+
|
|
311
|
+
@functools.wraps(fn)
|
|
312
|
+
def deprecated_fn(*args, **kwargs):
|
|
313
|
+
warnings.warn(message)
|
|
314
|
+
pulumi.warn(f"{fn.__name__} is deprecated: {message}")
|
|
315
|
+
|
|
316
|
+
return fn(*args, **kwargs)
|
|
317
|
+
|
|
318
|
+
deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn
|
|
319
|
+
return typing.cast(C, deprecated_fn)
|
|
320
|
+
|
|
321
|
+
return decorator
|
|
322
|
+
|
|
290
323
|
def get_plugin_download_url():
|
|
291
324
|
return None
|
|
325
|
+
|
|
326
|
+
def get_version():
|
|
327
|
+
return _version_str
|
|
@@ -4,9 +4,14 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
|
|
12
17
|
apiKey: Optional[str]
|
pulumi_mailgun/config/vars.py
CHANGED
|
@@ -4,9 +4,14 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
|
|
12
17
|
import types
|
pulumi_mailgun/domain.py
CHANGED
|
@@ -4,9 +4,14 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,6 +21,7 @@ __all__ = ['DomainArgs', 'Domain']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class DomainArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
24
|
+
click_tracking: Optional[pulumi.Input[bool]] = None,
|
|
19
25
|
dkim_key_size: Optional[pulumi.Input[int]] = None,
|
|
20
26
|
dkim_selector: Optional[pulumi.Input[str]] = None,
|
|
21
27
|
force_dkim_authority: Optional[pulumi.Input[bool]] = None,
|
|
@@ -24,9 +30,11 @@ class DomainArgs:
|
|
|
24
30
|
region: Optional[pulumi.Input[str]] = None,
|
|
25
31
|
smtp_password: Optional[pulumi.Input[str]] = None,
|
|
26
32
|
spam_action: Optional[pulumi.Input[str]] = None,
|
|
33
|
+
web_scheme: Optional[pulumi.Input[str]] = None,
|
|
27
34
|
wildcard: Optional[pulumi.Input[bool]] = None):
|
|
28
35
|
"""
|
|
29
36
|
The set of arguments for constructing a Domain resource.
|
|
37
|
+
:param pulumi.Input[bool] click_tracking: (Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
30
38
|
:param pulumi.Input[int] dkim_key_size: The length of your domain’s generated DKIM key. Default value is `1024`.
|
|
31
39
|
:param pulumi.Input[str] dkim_selector: The name of your DKIM selector if you want to specify it whereas MailGun will make it's own choice.
|
|
32
40
|
:param pulumi.Input[bool] force_dkim_authority: If set to true, the domain will be the DKIM authority for itself even if the root domain is registered on the same mailgun account. If set to false, the domain will have the same DKIM authority as the root domain registered on the same mailgun account. The default is `false`.
|
|
@@ -37,9 +45,12 @@ class DomainArgs:
|
|
|
37
45
|
:param pulumi.Input[str] spam_action: `disabled` or `tag` Disable, no spam
|
|
38
46
|
filtering will occur for inbound messages. Tag, messages
|
|
39
47
|
will be tagged with a spam header. Default value is `disabled`.
|
|
48
|
+
:param pulumi.Input[str] web_scheme: (`http` or `https`) The tracking web scheme. Default: `http`
|
|
40
49
|
:param pulumi.Input[bool] wildcard: Boolean that determines whether
|
|
41
50
|
the domain will accept email for sub-domains.
|
|
42
51
|
"""
|
|
52
|
+
if click_tracking is not None:
|
|
53
|
+
pulumi.set(__self__, "click_tracking", click_tracking)
|
|
43
54
|
if dkim_key_size is not None:
|
|
44
55
|
pulumi.set(__self__, "dkim_key_size", dkim_key_size)
|
|
45
56
|
if dkim_selector is not None:
|
|
@@ -56,9 +67,23 @@ class DomainArgs:
|
|
|
56
67
|
pulumi.set(__self__, "smtp_password", smtp_password)
|
|
57
68
|
if spam_action is not None:
|
|
58
69
|
pulumi.set(__self__, "spam_action", spam_action)
|
|
70
|
+
if web_scheme is not None:
|
|
71
|
+
pulumi.set(__self__, "web_scheme", web_scheme)
|
|
59
72
|
if wildcard is not None:
|
|
60
73
|
pulumi.set(__self__, "wildcard", wildcard)
|
|
61
74
|
|
|
75
|
+
@property
|
|
76
|
+
@pulumi.getter(name="clickTracking")
|
|
77
|
+
def click_tracking(self) -> Optional[pulumi.Input[bool]]:
|
|
78
|
+
"""
|
|
79
|
+
(Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
80
|
+
"""
|
|
81
|
+
return pulumi.get(self, "click_tracking")
|
|
82
|
+
|
|
83
|
+
@click_tracking.setter
|
|
84
|
+
def click_tracking(self, value: Optional[pulumi.Input[bool]]):
|
|
85
|
+
pulumi.set(self, "click_tracking", value)
|
|
86
|
+
|
|
62
87
|
@property
|
|
63
88
|
@pulumi.getter(name="dkimKeySize")
|
|
64
89
|
def dkim_key_size(self) -> Optional[pulumi.Input[int]]:
|
|
@@ -157,6 +182,18 @@ class DomainArgs:
|
|
|
157
182
|
def spam_action(self, value: Optional[pulumi.Input[str]]):
|
|
158
183
|
pulumi.set(self, "spam_action", value)
|
|
159
184
|
|
|
185
|
+
@property
|
|
186
|
+
@pulumi.getter(name="webScheme")
|
|
187
|
+
def web_scheme(self) -> Optional[pulumi.Input[str]]:
|
|
188
|
+
"""
|
|
189
|
+
(`http` or `https`) The tracking web scheme. Default: `http`
|
|
190
|
+
"""
|
|
191
|
+
return pulumi.get(self, "web_scheme")
|
|
192
|
+
|
|
193
|
+
@web_scheme.setter
|
|
194
|
+
def web_scheme(self, value: Optional[pulumi.Input[str]]):
|
|
195
|
+
pulumi.set(self, "web_scheme", value)
|
|
196
|
+
|
|
160
197
|
@property
|
|
161
198
|
@pulumi.getter
|
|
162
199
|
def wildcard(self) -> Optional[pulumi.Input[bool]]:
|
|
@@ -174,6 +211,7 @@ class DomainArgs:
|
|
|
174
211
|
@pulumi.input_type
|
|
175
212
|
class _DomainState:
|
|
176
213
|
def __init__(__self__, *,
|
|
214
|
+
click_tracking: Optional[pulumi.Input[bool]] = None,
|
|
177
215
|
dkim_key_size: Optional[pulumi.Input[int]] = None,
|
|
178
216
|
dkim_selector: Optional[pulumi.Input[str]] = None,
|
|
179
217
|
force_dkim_authority: Optional[pulumi.Input[bool]] = None,
|
|
@@ -187,9 +225,11 @@ class _DomainState:
|
|
|
187
225
|
smtp_login: Optional[pulumi.Input[str]] = None,
|
|
188
226
|
smtp_password: Optional[pulumi.Input[str]] = None,
|
|
189
227
|
spam_action: Optional[pulumi.Input[str]] = None,
|
|
228
|
+
web_scheme: Optional[pulumi.Input[str]] = None,
|
|
190
229
|
wildcard: Optional[pulumi.Input[bool]] = None):
|
|
191
230
|
"""
|
|
192
231
|
Input properties used for looking up and filtering Domain resources.
|
|
232
|
+
:param pulumi.Input[bool] click_tracking: (Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
193
233
|
:param pulumi.Input[int] dkim_key_size: The length of your domain’s generated DKIM key. Default value is `1024`.
|
|
194
234
|
:param pulumi.Input[str] dkim_selector: The name of your DKIM selector if you want to specify it whereas MailGun will make it's own choice.
|
|
195
235
|
:param pulumi.Input[bool] force_dkim_authority: If set to true, the domain will be the DKIM authority for itself even if the root domain is registered on the same mailgun account. If set to false, the domain will have the same DKIM authority as the root domain registered on the same mailgun account. The default is `false`.
|
|
@@ -205,9 +245,12 @@ class _DomainState:
|
|
|
205
245
|
:param pulumi.Input[str] spam_action: `disabled` or `tag` Disable, no spam
|
|
206
246
|
filtering will occur for inbound messages. Tag, messages
|
|
207
247
|
will be tagged with a spam header. Default value is `disabled`.
|
|
248
|
+
:param pulumi.Input[str] web_scheme: (`http` or `https`) The tracking web scheme. Default: `http`
|
|
208
249
|
:param pulumi.Input[bool] wildcard: Boolean that determines whether
|
|
209
250
|
the domain will accept email for sub-domains.
|
|
210
251
|
"""
|
|
252
|
+
if click_tracking is not None:
|
|
253
|
+
pulumi.set(__self__, "click_tracking", click_tracking)
|
|
211
254
|
if dkim_key_size is not None:
|
|
212
255
|
pulumi.set(__self__, "dkim_key_size", dkim_key_size)
|
|
213
256
|
if dkim_selector is not None:
|
|
@@ -240,9 +283,23 @@ class _DomainState:
|
|
|
240
283
|
pulumi.set(__self__, "smtp_password", smtp_password)
|
|
241
284
|
if spam_action is not None:
|
|
242
285
|
pulumi.set(__self__, "spam_action", spam_action)
|
|
286
|
+
if web_scheme is not None:
|
|
287
|
+
pulumi.set(__self__, "web_scheme", web_scheme)
|
|
243
288
|
if wildcard is not None:
|
|
244
289
|
pulumi.set(__self__, "wildcard", wildcard)
|
|
245
290
|
|
|
291
|
+
@property
|
|
292
|
+
@pulumi.getter(name="clickTracking")
|
|
293
|
+
def click_tracking(self) -> Optional[pulumi.Input[bool]]:
|
|
294
|
+
"""
|
|
295
|
+
(Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
296
|
+
"""
|
|
297
|
+
return pulumi.get(self, "click_tracking")
|
|
298
|
+
|
|
299
|
+
@click_tracking.setter
|
|
300
|
+
def click_tracking(self, value: Optional[pulumi.Input[bool]]):
|
|
301
|
+
pulumi.set(self, "click_tracking", value)
|
|
302
|
+
|
|
246
303
|
@property
|
|
247
304
|
@pulumi.getter(name="dkimKeySize")
|
|
248
305
|
def dkim_key_size(self) -> Optional[pulumi.Input[int]]:
|
|
@@ -305,13 +362,11 @@ class _DomainState:
|
|
|
305
362
|
|
|
306
363
|
@property
|
|
307
364
|
@pulumi.getter(name="receivingRecords")
|
|
365
|
+
@_utilities.deprecated("""Use `receiving_records_set` instead.""")
|
|
308
366
|
def receiving_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DomainReceivingRecordArgs']]]]:
|
|
309
367
|
"""
|
|
310
368
|
A list of DNS records for receiving validation. **Deprecated** Use `receiving_records_set` instead.
|
|
311
369
|
"""
|
|
312
|
-
warnings.warn("""Use `receiving_records_set` instead.""", DeprecationWarning)
|
|
313
|
-
pulumi.log.warn("""receiving_records is deprecated: Use `receiving_records_set` instead.""")
|
|
314
|
-
|
|
315
370
|
return pulumi.get(self, "receiving_records")
|
|
316
371
|
|
|
317
372
|
@receiving_records.setter
|
|
@@ -344,13 +399,11 @@ class _DomainState:
|
|
|
344
399
|
|
|
345
400
|
@property
|
|
346
401
|
@pulumi.getter(name="sendingRecords")
|
|
402
|
+
@_utilities.deprecated("""Use `sending_records_set` instead.""")
|
|
347
403
|
def sending_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DomainSendingRecordArgs']]]]:
|
|
348
404
|
"""
|
|
349
405
|
A list of DNS records for sending validation. **Deprecated** Use `sending_records_set` instead.
|
|
350
406
|
"""
|
|
351
|
-
warnings.warn("""Use `sending_records_set` instead.""", DeprecationWarning)
|
|
352
|
-
pulumi.log.warn("""sending_records is deprecated: Use `sending_records_set` instead.""")
|
|
353
|
-
|
|
354
407
|
return pulumi.get(self, "sending_records")
|
|
355
408
|
|
|
356
409
|
@sending_records.setter
|
|
@@ -407,6 +460,18 @@ class _DomainState:
|
|
|
407
460
|
def spam_action(self, value: Optional[pulumi.Input[str]]):
|
|
408
461
|
pulumi.set(self, "spam_action", value)
|
|
409
462
|
|
|
463
|
+
@property
|
|
464
|
+
@pulumi.getter(name="webScheme")
|
|
465
|
+
def web_scheme(self) -> Optional[pulumi.Input[str]]:
|
|
466
|
+
"""
|
|
467
|
+
(`http` or `https`) The tracking web scheme. Default: `http`
|
|
468
|
+
"""
|
|
469
|
+
return pulumi.get(self, "web_scheme")
|
|
470
|
+
|
|
471
|
+
@web_scheme.setter
|
|
472
|
+
def web_scheme(self, value: Optional[pulumi.Input[str]]):
|
|
473
|
+
pulumi.set(self, "web_scheme", value)
|
|
474
|
+
|
|
410
475
|
@property
|
|
411
476
|
@pulumi.getter
|
|
412
477
|
def wildcard(self) -> Optional[pulumi.Input[bool]]:
|
|
@@ -426,6 +491,7 @@ class Domain(pulumi.CustomResource):
|
|
|
426
491
|
def __init__(__self__,
|
|
427
492
|
resource_name: str,
|
|
428
493
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
494
|
+
click_tracking: Optional[pulumi.Input[bool]] = None,
|
|
429
495
|
dkim_key_size: Optional[pulumi.Input[int]] = None,
|
|
430
496
|
dkim_selector: Optional[pulumi.Input[str]] = None,
|
|
431
497
|
force_dkim_authority: Optional[pulumi.Input[bool]] = None,
|
|
@@ -434,6 +500,7 @@ class Domain(pulumi.CustomResource):
|
|
|
434
500
|
region: Optional[pulumi.Input[str]] = None,
|
|
435
501
|
smtp_password: Optional[pulumi.Input[str]] = None,
|
|
436
502
|
spam_action: Optional[pulumi.Input[str]] = None,
|
|
503
|
+
web_scheme: Optional[pulumi.Input[str]] = None,
|
|
437
504
|
wildcard: Optional[pulumi.Input[bool]] = None,
|
|
438
505
|
__props__=None):
|
|
439
506
|
"""
|
|
@@ -444,19 +511,18 @@ class Domain(pulumi.CustomResource):
|
|
|
444
511
|
|
|
445
512
|
## Example Usage
|
|
446
513
|
|
|
447
|
-
<!--Start PulumiCodeChooser -->
|
|
448
514
|
```python
|
|
449
515
|
import pulumi
|
|
450
516
|
import pulumi_mailgun as mailgun
|
|
451
517
|
|
|
452
518
|
# Create a new Mailgun domain
|
|
453
519
|
default = mailgun.Domain("default",
|
|
454
|
-
|
|
520
|
+
name="test.example.com",
|
|
455
521
|
region="us",
|
|
522
|
+
spam_action="disabled",
|
|
456
523
|
smtp_password="supersecretpassword1234",
|
|
457
|
-
|
|
524
|
+
dkim_key_size=1024)
|
|
458
525
|
```
|
|
459
|
-
<!--End PulumiCodeChooser -->
|
|
460
526
|
|
|
461
527
|
## Import
|
|
462
528
|
|
|
@@ -470,6 +536,7 @@ class Domain(pulumi.CustomResource):
|
|
|
470
536
|
|
|
471
537
|
:param str resource_name: The name of the resource.
|
|
472
538
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
539
|
+
:param pulumi.Input[bool] click_tracking: (Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
473
540
|
:param pulumi.Input[int] dkim_key_size: The length of your domain’s generated DKIM key. Default value is `1024`.
|
|
474
541
|
:param pulumi.Input[str] dkim_selector: The name of your DKIM selector if you want to specify it whereas MailGun will make it's own choice.
|
|
475
542
|
:param pulumi.Input[bool] force_dkim_authority: If set to true, the domain will be the DKIM authority for itself even if the root domain is registered on the same mailgun account. If set to false, the domain will have the same DKIM authority as the root domain registered on the same mailgun account. The default is `false`.
|
|
@@ -480,6 +547,7 @@ class Domain(pulumi.CustomResource):
|
|
|
480
547
|
:param pulumi.Input[str] spam_action: `disabled` or `tag` Disable, no spam
|
|
481
548
|
filtering will occur for inbound messages. Tag, messages
|
|
482
549
|
will be tagged with a spam header. Default value is `disabled`.
|
|
550
|
+
:param pulumi.Input[str] web_scheme: (`http` or `https`) The tracking web scheme. Default: `http`
|
|
483
551
|
:param pulumi.Input[bool] wildcard: Boolean that determines whether
|
|
484
552
|
the domain will accept email for sub-domains.
|
|
485
553
|
"""
|
|
@@ -497,19 +565,18 @@ class Domain(pulumi.CustomResource):
|
|
|
497
565
|
|
|
498
566
|
## Example Usage
|
|
499
567
|
|
|
500
|
-
<!--Start PulumiCodeChooser -->
|
|
501
568
|
```python
|
|
502
569
|
import pulumi
|
|
503
570
|
import pulumi_mailgun as mailgun
|
|
504
571
|
|
|
505
572
|
# Create a new Mailgun domain
|
|
506
573
|
default = mailgun.Domain("default",
|
|
507
|
-
|
|
574
|
+
name="test.example.com",
|
|
508
575
|
region="us",
|
|
576
|
+
spam_action="disabled",
|
|
509
577
|
smtp_password="supersecretpassword1234",
|
|
510
|
-
|
|
578
|
+
dkim_key_size=1024)
|
|
511
579
|
```
|
|
512
|
-
<!--End PulumiCodeChooser -->
|
|
513
580
|
|
|
514
581
|
## Import
|
|
515
582
|
|
|
@@ -536,6 +603,7 @@ class Domain(pulumi.CustomResource):
|
|
|
536
603
|
def _internal_init(__self__,
|
|
537
604
|
resource_name: str,
|
|
538
605
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
606
|
+
click_tracking: Optional[pulumi.Input[bool]] = None,
|
|
539
607
|
dkim_key_size: Optional[pulumi.Input[int]] = None,
|
|
540
608
|
dkim_selector: Optional[pulumi.Input[str]] = None,
|
|
541
609
|
force_dkim_authority: Optional[pulumi.Input[bool]] = None,
|
|
@@ -544,6 +612,7 @@ class Domain(pulumi.CustomResource):
|
|
|
544
612
|
region: Optional[pulumi.Input[str]] = None,
|
|
545
613
|
smtp_password: Optional[pulumi.Input[str]] = None,
|
|
546
614
|
spam_action: Optional[pulumi.Input[str]] = None,
|
|
615
|
+
web_scheme: Optional[pulumi.Input[str]] = None,
|
|
547
616
|
wildcard: Optional[pulumi.Input[bool]] = None,
|
|
548
617
|
__props__=None):
|
|
549
618
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -554,6 +623,7 @@ class Domain(pulumi.CustomResource):
|
|
|
554
623
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
555
624
|
__props__ = DomainArgs.__new__(DomainArgs)
|
|
556
625
|
|
|
626
|
+
__props__.__dict__["click_tracking"] = click_tracking
|
|
557
627
|
__props__.__dict__["dkim_key_size"] = dkim_key_size
|
|
558
628
|
__props__.__dict__["dkim_selector"] = dkim_selector
|
|
559
629
|
__props__.__dict__["force_dkim_authority"] = force_dkim_authority
|
|
@@ -562,6 +632,7 @@ class Domain(pulumi.CustomResource):
|
|
|
562
632
|
__props__.__dict__["region"] = region
|
|
563
633
|
__props__.__dict__["smtp_password"] = None if smtp_password is None else pulumi.Output.secret(smtp_password)
|
|
564
634
|
__props__.__dict__["spam_action"] = spam_action
|
|
635
|
+
__props__.__dict__["web_scheme"] = web_scheme
|
|
565
636
|
__props__.__dict__["wildcard"] = wildcard
|
|
566
637
|
__props__.__dict__["receiving_records"] = None
|
|
567
638
|
__props__.__dict__["receiving_records_sets"] = None
|
|
@@ -580,19 +651,21 @@ class Domain(pulumi.CustomResource):
|
|
|
580
651
|
def get(resource_name: str,
|
|
581
652
|
id: pulumi.Input[str],
|
|
582
653
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
654
|
+
click_tracking: Optional[pulumi.Input[bool]] = None,
|
|
583
655
|
dkim_key_size: Optional[pulumi.Input[int]] = None,
|
|
584
656
|
dkim_selector: Optional[pulumi.Input[str]] = None,
|
|
585
657
|
force_dkim_authority: Optional[pulumi.Input[bool]] = None,
|
|
586
658
|
name: Optional[pulumi.Input[str]] = None,
|
|
587
659
|
open_tracking: Optional[pulumi.Input[bool]] = None,
|
|
588
|
-
receiving_records: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
589
|
-
receiving_records_sets: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
660
|
+
receiving_records: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DomainReceivingRecordArgs', 'DomainReceivingRecordArgsDict']]]]] = None,
|
|
661
|
+
receiving_records_sets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DomainReceivingRecordsSetArgs', 'DomainReceivingRecordsSetArgsDict']]]]] = None,
|
|
590
662
|
region: Optional[pulumi.Input[str]] = None,
|
|
591
|
-
sending_records: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
592
|
-
sending_records_sets: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
663
|
+
sending_records: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DomainSendingRecordArgs', 'DomainSendingRecordArgsDict']]]]] = None,
|
|
664
|
+
sending_records_sets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DomainSendingRecordsSetArgs', 'DomainSendingRecordsSetArgsDict']]]]] = None,
|
|
593
665
|
smtp_login: Optional[pulumi.Input[str]] = None,
|
|
594
666
|
smtp_password: Optional[pulumi.Input[str]] = None,
|
|
595
667
|
spam_action: Optional[pulumi.Input[str]] = None,
|
|
668
|
+
web_scheme: Optional[pulumi.Input[str]] = None,
|
|
596
669
|
wildcard: Optional[pulumi.Input[bool]] = None) -> 'Domain':
|
|
597
670
|
"""
|
|
598
671
|
Get an existing Domain resource's state with the given name, id, and optional extra
|
|
@@ -601,21 +674,23 @@ class Domain(pulumi.CustomResource):
|
|
|
601
674
|
:param str resource_name: The unique name of the resulting resource.
|
|
602
675
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
603
676
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
677
|
+
:param pulumi.Input[bool] click_tracking: (Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
604
678
|
:param pulumi.Input[int] dkim_key_size: The length of your domain’s generated DKIM key. Default value is `1024`.
|
|
605
679
|
:param pulumi.Input[str] dkim_selector: The name of your DKIM selector if you want to specify it whereas MailGun will make it's own choice.
|
|
606
680
|
:param pulumi.Input[bool] force_dkim_authority: If set to true, the domain will be the DKIM authority for itself even if the root domain is registered on the same mailgun account. If set to false, the domain will have the same DKIM authority as the root domain registered on the same mailgun account. The default is `false`.
|
|
607
681
|
:param pulumi.Input[str] name: The domain to add to Mailgun
|
|
608
682
|
:param pulumi.Input[bool] open_tracking: (Enum: `yes` or `no`) The open tracking settings for the domain. Default: `no`
|
|
609
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
610
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
683
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DomainReceivingRecordArgs', 'DomainReceivingRecordArgsDict']]]] receiving_records: A list of DNS records for receiving validation. **Deprecated** Use `receiving_records_set` instead.
|
|
684
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DomainReceivingRecordsSetArgs', 'DomainReceivingRecordsSetArgsDict']]]] receiving_records_sets: A set of DNS records for receiving validation.
|
|
611
685
|
:param pulumi.Input[str] region: The region where domain will be created. Default value is `us`.
|
|
612
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
613
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
686
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DomainSendingRecordArgs', 'DomainSendingRecordArgsDict']]]] sending_records: A list of DNS records for sending validation. **Deprecated** Use `sending_records_set` instead.
|
|
687
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DomainSendingRecordsSetArgs', 'DomainSendingRecordsSetArgsDict']]]] sending_records_sets: A set of DNS records for sending validation.
|
|
614
688
|
:param pulumi.Input[str] smtp_login: The login email for the SMTP server.
|
|
615
689
|
:param pulumi.Input[str] smtp_password: Password for SMTP authentication
|
|
616
690
|
:param pulumi.Input[str] spam_action: `disabled` or `tag` Disable, no spam
|
|
617
691
|
filtering will occur for inbound messages. Tag, messages
|
|
618
692
|
will be tagged with a spam header. Default value is `disabled`.
|
|
693
|
+
:param pulumi.Input[str] web_scheme: (`http` or `https`) The tracking web scheme. Default: `http`
|
|
619
694
|
:param pulumi.Input[bool] wildcard: Boolean that determines whether
|
|
620
695
|
the domain will accept email for sub-domains.
|
|
621
696
|
"""
|
|
@@ -623,6 +698,7 @@ class Domain(pulumi.CustomResource):
|
|
|
623
698
|
|
|
624
699
|
__props__ = _DomainState.__new__(_DomainState)
|
|
625
700
|
|
|
701
|
+
__props__.__dict__["click_tracking"] = click_tracking
|
|
626
702
|
__props__.__dict__["dkim_key_size"] = dkim_key_size
|
|
627
703
|
__props__.__dict__["dkim_selector"] = dkim_selector
|
|
628
704
|
__props__.__dict__["force_dkim_authority"] = force_dkim_authority
|
|
@@ -636,9 +712,18 @@ class Domain(pulumi.CustomResource):
|
|
|
636
712
|
__props__.__dict__["smtp_login"] = smtp_login
|
|
637
713
|
__props__.__dict__["smtp_password"] = smtp_password
|
|
638
714
|
__props__.__dict__["spam_action"] = spam_action
|
|
715
|
+
__props__.__dict__["web_scheme"] = web_scheme
|
|
639
716
|
__props__.__dict__["wildcard"] = wildcard
|
|
640
717
|
return Domain(resource_name, opts=opts, __props__=__props__)
|
|
641
718
|
|
|
719
|
+
@property
|
|
720
|
+
@pulumi.getter(name="clickTracking")
|
|
721
|
+
def click_tracking(self) -> pulumi.Output[Optional[bool]]:
|
|
722
|
+
"""
|
|
723
|
+
(Enum: `yes` or `no`) The click tracking settings for the domain. Default: `no`
|
|
724
|
+
"""
|
|
725
|
+
return pulumi.get(self, "click_tracking")
|
|
726
|
+
|
|
642
727
|
@property
|
|
643
728
|
@pulumi.getter(name="dkimKeySize")
|
|
644
729
|
def dkim_key_size(self) -> pulumi.Output[Optional[int]]:
|
|
@@ -681,13 +766,11 @@ class Domain(pulumi.CustomResource):
|
|
|
681
766
|
|
|
682
767
|
@property
|
|
683
768
|
@pulumi.getter(name="receivingRecords")
|
|
769
|
+
@_utilities.deprecated("""Use `receiving_records_set` instead.""")
|
|
684
770
|
def receiving_records(self) -> pulumi.Output[Sequence['outputs.DomainReceivingRecord']]:
|
|
685
771
|
"""
|
|
686
772
|
A list of DNS records for receiving validation. **Deprecated** Use `receiving_records_set` instead.
|
|
687
773
|
"""
|
|
688
|
-
warnings.warn("""Use `receiving_records_set` instead.""", DeprecationWarning)
|
|
689
|
-
pulumi.log.warn("""receiving_records is deprecated: Use `receiving_records_set` instead.""")
|
|
690
|
-
|
|
691
774
|
return pulumi.get(self, "receiving_records")
|
|
692
775
|
|
|
693
776
|
@property
|
|
@@ -708,13 +791,11 @@ class Domain(pulumi.CustomResource):
|
|
|
708
791
|
|
|
709
792
|
@property
|
|
710
793
|
@pulumi.getter(name="sendingRecords")
|
|
794
|
+
@_utilities.deprecated("""Use `sending_records_set` instead.""")
|
|
711
795
|
def sending_records(self) -> pulumi.Output[Sequence['outputs.DomainSendingRecord']]:
|
|
712
796
|
"""
|
|
713
797
|
A list of DNS records for sending validation. **Deprecated** Use `sending_records_set` instead.
|
|
714
798
|
"""
|
|
715
|
-
warnings.warn("""Use `sending_records_set` instead.""", DeprecationWarning)
|
|
716
|
-
pulumi.log.warn("""sending_records is deprecated: Use `sending_records_set` instead.""")
|
|
717
|
-
|
|
718
799
|
return pulumi.get(self, "sending_records")
|
|
719
800
|
|
|
720
801
|
@property
|
|
@@ -751,6 +832,14 @@ class Domain(pulumi.CustomResource):
|
|
|
751
832
|
"""
|
|
752
833
|
return pulumi.get(self, "spam_action")
|
|
753
834
|
|
|
835
|
+
@property
|
|
836
|
+
@pulumi.getter(name="webScheme")
|
|
837
|
+
def web_scheme(self) -> pulumi.Output[Optional[str]]:
|
|
838
|
+
"""
|
|
839
|
+
(`http` or `https`) The tracking web scheme. Default: `http`
|
|
840
|
+
"""
|
|
841
|
+
return pulumi.get(self, "web_scheme")
|
|
842
|
+
|
|
754
843
|
@property
|
|
755
844
|
@pulumi.getter
|
|
756
845
|
def wildcard(self) -> pulumi.Output[Optional[bool]]:
|