pulumi-newrelic 5.48.0a1752732890__py3-none-any.whl → 5.58.0a1766556761__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.
Files changed (91) hide show
  1. pulumi_newrelic/__init__.py +18 -1
  2. pulumi_newrelic/_inputs.py +4269 -3795
  3. pulumi_newrelic/account_management.py +35 -36
  4. pulumi_newrelic/alert_channel.py +61 -62
  5. pulumi_newrelic/alert_condition.py +217 -218
  6. pulumi_newrelic/alert_muting_rule.py +92 -93
  7. pulumi_newrelic/alert_policy.py +69 -70
  8. pulumi_newrelic/alert_policy_channel.py +52 -53
  9. pulumi_newrelic/api_access_key.py +190 -159
  10. pulumi_newrelic/browser_application.py +113 -114
  11. pulumi_newrelic/cloud/__init__.py +2 -1
  12. pulumi_newrelic/cloud/_inputs.py +2183 -2130
  13. pulumi_newrelic/cloud/aws_govcloud_integrations.py +99 -96
  14. pulumi_newrelic/cloud/aws_govcloud_link_account.py +69 -70
  15. pulumi_newrelic/cloud/aws_integrations.py +194 -195
  16. pulumi_newrelic/cloud/aws_link_account.py +69 -70
  17. pulumi_newrelic/cloud/azure_integrations.py +178 -132
  18. pulumi_newrelic/cloud/azure_link_account.py +103 -104
  19. pulumi_newrelic/cloud/gcp_integrations.py +113 -114
  20. pulumi_newrelic/cloud/gcp_link_account.py +52 -53
  21. pulumi_newrelic/cloud/oci_link_account.py +926 -0
  22. pulumi_newrelic/cloud/outputs.py +1468 -1418
  23. pulumi_newrelic/config/__init__.py +1 -1
  24. pulumi_newrelic/config/__init__.pyi +1 -2
  25. pulumi_newrelic/config/vars.py +14 -15
  26. pulumi_newrelic/data_partition_rule.py +112 -113
  27. pulumi_newrelic/entity_tags.py +77 -22
  28. pulumi_newrelic/events_to_metrics_rule.py +95 -96
  29. pulumi_newrelic/get_account.py +21 -22
  30. pulumi_newrelic/get_alert_channel.py +52 -21
  31. pulumi_newrelic/get_alert_policy.py +51 -26
  32. pulumi_newrelic/get_application.py +13 -14
  33. pulumi_newrelic/get_authentication_domain.py +9 -10
  34. pulumi_newrelic/get_cloud_account.py +21 -22
  35. pulumi_newrelic/get_entity.py +52 -53
  36. pulumi_newrelic/get_group.py +17 -18
  37. pulumi_newrelic/get_key_transaction.py +25 -26
  38. pulumi_newrelic/get_notification_destination.py +29 -30
  39. pulumi_newrelic/get_obfuscation_expression.py +15 -16
  40. pulumi_newrelic/get_service_level_alert_helper.py +53 -54
  41. pulumi_newrelic/get_test_grok_pattern.py +22 -23
  42. pulumi_newrelic/get_user.py +21 -22
  43. pulumi_newrelic/group.py +52 -53
  44. pulumi_newrelic/infra_alert_condition.py +255 -256
  45. pulumi_newrelic/insights/__init__.py +1 -1
  46. pulumi_newrelic/insights/_inputs.py +32 -33
  47. pulumi_newrelic/insights/event.py +4 -5
  48. pulumi_newrelic/insights/outputs.py +22 -23
  49. pulumi_newrelic/key_transaction.py +104 -105
  50. pulumi_newrelic/log_parsing_rule.py +146 -147
  51. pulumi_newrelic/monitor_downtime.py +146 -154
  52. pulumi_newrelic/notification_channel.py +159 -160
  53. pulumi_newrelic/notification_destination.py +114 -129
  54. pulumi_newrelic/nrql_alert_condition.py +479 -431
  55. pulumi_newrelic/nrql_drop_rule.py +106 -147
  56. pulumi_newrelic/obfuscation_expression.py +69 -70
  57. pulumi_newrelic/obfuscation_rule.py +89 -90
  58. pulumi_newrelic/one_dashboard.py +93 -94
  59. pulumi_newrelic/one_dashboard_json.py +62 -63
  60. pulumi_newrelic/one_dashboard_raw.py +114 -115
  61. pulumi_newrelic/outputs.py +2991 -2673
  62. pulumi_newrelic/pipeline_cloud_rule.py +335 -0
  63. pulumi_newrelic/plugins/__init__.py +1 -1
  64. pulumi_newrelic/plugins/_inputs.py +158 -159
  65. pulumi_newrelic/plugins/application_settings.py +167 -168
  66. pulumi_newrelic/plugins/outputs.py +108 -109
  67. pulumi_newrelic/plugins/workload.py +131 -132
  68. pulumi_newrelic/provider.py +106 -107
  69. pulumi_newrelic/pulumi-plugin.json +1 -1
  70. pulumi_newrelic/service_level.py +76 -77
  71. pulumi_newrelic/synthetics/__init__.py +1 -1
  72. pulumi_newrelic/synthetics/_inputs.py +127 -128
  73. pulumi_newrelic/synthetics/alert_condition.py +95 -96
  74. pulumi_newrelic/synthetics/broken_links_monitor.py +197 -198
  75. pulumi_newrelic/synthetics/cert_check_monitor.py +205 -206
  76. pulumi_newrelic/synthetics/get_private_location.py +21 -22
  77. pulumi_newrelic/synthetics/get_secure_credential.py +19 -20
  78. pulumi_newrelic/synthetics/monitor.py +378 -379
  79. pulumi_newrelic/synthetics/multi_location_alert_condition.py +118 -119
  80. pulumi_newrelic/synthetics/outputs.py +85 -86
  81. pulumi_newrelic/synthetics/private_location.py +105 -106
  82. pulumi_newrelic/synthetics/script_monitor.py +364 -303
  83. pulumi_newrelic/synthetics/secure_credential.py +86 -87
  84. pulumi_newrelic/synthetics/step_monitor.py +220 -221
  85. pulumi_newrelic/user.py +69 -70
  86. pulumi_newrelic/workflow.py +139 -140
  87. {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/METADATA +1 -1
  88. pulumi_newrelic-5.58.0a1766556761.dist-info/RECORD +92 -0
  89. pulumi_newrelic-5.48.0a1752732890.dist-info/RECORD +0 -90
  90. {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/WHEEL +0 -0
  91. {pulumi_newrelic-5.48.0a1752732890.dist-info → pulumi_newrelic-5.58.0a1766556761.dist-info}/top_level.txt +0 -0
pulumi_newrelic/api_access_key.py CHANGED
@@ -2,8 +2,7 @@
2
2
  # *** WARNING: this file was generated by pulumi-language-python. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
- import builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -20,23 +19,25 @@ __all__ = ['ApiAccessKeyArgs', 'ApiAccessKey']
20
19
  @pulumi.input_type
21
20
  class ApiAccessKeyArgs:
22
21
  def __init__(__self__, *,
23
- account_id: pulumi.Input[builtins.str],
24
- key_type: pulumi.Input[builtins.str],
25
- ingest_type: Optional[pulumi.Input[builtins.str]] = None,
26
- name: Optional[pulumi.Input[builtins.str]] = None,
27
- notes: Optional[pulumi.Input[builtins.str]] = None,
28
- user_id: Optional[pulumi.Input[builtins.str]] = None):
22
+ key_type: pulumi.Input[_builtins.str],
23
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
24
+ ingest_type: Optional[pulumi.Input[_builtins.str]] = None,
25
+ name: Optional[pulumi.Input[_builtins.str]] = None,
26
+ notes: Optional[pulumi.Input[_builtins.str]] = None,
27
+ user_id: Optional[pulumi.Input[_builtins.str]] = None):
29
28
  """
30
29
  The set of arguments for constructing a ApiAccessKey resource.
31
- :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the API access key.
32
- :param pulumi.Input[builtins.str] key_type: What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
33
- :param pulumi.Input[builtins.str] ingest_type: Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
34
- :param pulumi.Input[builtins.str] name: The name of the key.
35
- :param pulumi.Input[builtins.str] notes: Any notes about this ingest key.
36
- :param pulumi.Input[builtins.str] user_id: Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
37
- """
38
- pulumi.set(__self__, "account_id", account_id)
30
+ :param pulumi.Input[_builtins.str] key_type: The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
31
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
32
+ - If `key_type` is `USER`, then `user_id` must be specified.
33
+ :param pulumi.Input[_builtins.str] account_id: The New Relic account ID where the API access key will be created.
34
+ :param pulumi.Input[_builtins.str] ingest_type: Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
35
+ :param pulumi.Input[_builtins.str] notes: Additional notes about the API access key.
36
+ :param pulumi.Input[_builtins.str] user_id: Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
37
+ """
39
38
  pulumi.set(__self__, "key_type", key_type)
39
+ if account_id is not None:
40
+ pulumi.set(__self__, "account_id", account_id)
40
41
  if ingest_type is not None:
41
42
  pulumi.set(__self__, "ingest_type", ingest_type)
42
43
  if name is not None:
@@ -46,98 +47,99 @@ class ApiAccessKeyArgs:
46
47
  if user_id is not None:
47
48
  pulumi.set(__self__, "user_id", user_id)
48
49
 
49
- @property
50
- @pulumi.getter(name="accountId")
51
- def account_id(self) -> pulumi.Input[builtins.str]:
52
- """
53
- The New Relic account ID of the account you wish to create the API access key.
54
- """
55
- return pulumi.get(self, "account_id")
56
-
57
- @account_id.setter
58
- def account_id(self, value: pulumi.Input[builtins.str]):
59
- pulumi.set(self, "account_id", value)
60
-
61
- @property
50
+ @_builtins.property
62
51
  @pulumi.getter(name="keyType")
63
- def key_type(self) -> pulumi.Input[builtins.str]:
52
+ def key_type(self) -> pulumi.Input[_builtins.str]:
64
53
  """
65
- What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
54
+ The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
55
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
56
+ - If `key_type` is `USER`, then `user_id` must be specified.
66
57
  """
67
58
  return pulumi.get(self, "key_type")
68
59
 
69
60
  @key_type.setter
70
- def key_type(self, value: pulumi.Input[builtins.str]):
61
+ def key_type(self, value: pulumi.Input[_builtins.str]):
71
62
  pulumi.set(self, "key_type", value)
72
63
 
73
- @property
64
+ @_builtins.property
65
+ @pulumi.getter(name="accountId")
66
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
67
+ """
68
+ The New Relic account ID where the API access key will be created.
69
+ """
70
+ return pulumi.get(self, "account_id")
71
+
72
+ @account_id.setter
73
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
74
+ pulumi.set(self, "account_id", value)
75
+
76
+ @_builtins.property
74
77
  @pulumi.getter(name="ingestType")
75
- def ingest_type(self) -> Optional[pulumi.Input[builtins.str]]:
78
+ def ingest_type(self) -> Optional[pulumi.Input[_builtins.str]]:
76
79
  """
77
- Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
80
+ Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
78
81
  """
79
82
  return pulumi.get(self, "ingest_type")
80
83
 
81
84
  @ingest_type.setter
82
- def ingest_type(self, value: Optional[pulumi.Input[builtins.str]]):
85
+ def ingest_type(self, value: Optional[pulumi.Input[_builtins.str]]):
83
86
  pulumi.set(self, "ingest_type", value)
84
87
 
85
- @property
88
+ @_builtins.property
86
89
  @pulumi.getter
87
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
88
- """
89
- The name of the key.
90
- """
90
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
91
91
  return pulumi.get(self, "name")
92
92
 
93
93
  @name.setter
94
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
94
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
95
95
  pulumi.set(self, "name", value)
96
96
 
97
- @property
97
+ @_builtins.property
98
98
  @pulumi.getter
99
- def notes(self) -> Optional[pulumi.Input[builtins.str]]:
99
+ def notes(self) -> Optional[pulumi.Input[_builtins.str]]:
100
100
  """
101
- Any notes about this ingest key.
101
+ Additional notes about the API access key.
102
102
  """
103
103
  return pulumi.get(self, "notes")
104
104
 
105
105
  @notes.setter
106
- def notes(self, value: Optional[pulumi.Input[builtins.str]]):
106
+ def notes(self, value: Optional[pulumi.Input[_builtins.str]]):
107
107
  pulumi.set(self, "notes", value)
108
108
 
109
- @property
109
+ @_builtins.property
110
110
  @pulumi.getter(name="userId")
111
- def user_id(self) -> Optional[pulumi.Input[builtins.str]]:
111
+ def user_id(self) -> Optional[pulumi.Input[_builtins.str]]:
112
112
  """
113
- Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
113
+ Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
114
114
  """
115
115
  return pulumi.get(self, "user_id")
116
116
 
117
117
  @user_id.setter
118
- def user_id(self, value: Optional[pulumi.Input[builtins.str]]):
118
+ def user_id(self, value: Optional[pulumi.Input[_builtins.str]]):
119
119
  pulumi.set(self, "user_id", value)
120
120
 
121
121
 
122
122
  @pulumi.input_type
123
123
  class _ApiAccessKeyState:
124
124
  def __init__(__self__, *,
125
- account_id: Optional[pulumi.Input[builtins.str]] = None,
126
- ingest_type: Optional[pulumi.Input[builtins.str]] = None,
127
- key: Optional[pulumi.Input[builtins.str]] = None,
128
- key_type: Optional[pulumi.Input[builtins.str]] = None,
129
- name: Optional[pulumi.Input[builtins.str]] = None,
130
- notes: Optional[pulumi.Input[builtins.str]] = None,
131
- user_id: Optional[pulumi.Input[builtins.str]] = None):
125
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
126
+ ingest_type: Optional[pulumi.Input[_builtins.str]] = None,
127
+ key: Optional[pulumi.Input[_builtins.str]] = None,
128
+ key_type: Optional[pulumi.Input[_builtins.str]] = None,
129
+ name: Optional[pulumi.Input[_builtins.str]] = None,
130
+ notes: Optional[pulumi.Input[_builtins.str]] = None,
131
+ user_id: Optional[pulumi.Input[_builtins.str]] = None):
132
132
  """
133
133
  Input properties used for looking up and filtering ApiAccessKey resources.
134
- :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the API access key.
135
- :param pulumi.Input[builtins.str] ingest_type: Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
136
- :param pulumi.Input[builtins.str] key: The actual API key. This attribute is masked and not be visible in your terminal, CI, etc.
137
- :param pulumi.Input[builtins.str] key_type: What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
138
- :param pulumi.Input[builtins.str] name: The name of the key.
139
- :param pulumi.Input[builtins.str] notes: Any notes about this ingest key.
140
- :param pulumi.Input[builtins.str] user_id: Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
134
+ :param pulumi.Input[_builtins.str] account_id: The New Relic account ID where the API access key will be created.
135
+ :param pulumi.Input[_builtins.str] ingest_type: Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
136
+ :param pulumi.Input[_builtins.str] key: The actual API key.
137
+ - <span style="color:tomato;">It is important to exercise caution when exporting the value of `key`, as it is sensitive information</span>. Avoid logging or exposing it inappropriately.
138
+ :param pulumi.Input[_builtins.str] key_type: The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
139
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
140
+ - If `key_type` is `USER`, then `user_id` must be specified.
141
+ :param pulumi.Input[_builtins.str] notes: Additional notes about the API access key.
142
+ :param pulumi.Input[_builtins.str] user_id: Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
141
143
  """
142
144
  if account_id is not None:
143
145
  pulumi.set(__self__, "account_id", account_id)
@@ -154,88 +156,88 @@ class _ApiAccessKeyState:
154
156
  if user_id is not None:
155
157
  pulumi.set(__self__, "user_id", user_id)
156
158
 
157
- @property
159
+ @_builtins.property
158
160
  @pulumi.getter(name="accountId")
159
- def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
161
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
160
162
  """
161
- The New Relic account ID of the account you wish to create the API access key.
163
+ The New Relic account ID where the API access key will be created.
162
164
  """
163
165
  return pulumi.get(self, "account_id")
164
166
 
165
167
  @account_id.setter
166
- def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
168
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
167
169
  pulumi.set(self, "account_id", value)
168
170
 
169
- @property
171
+ @_builtins.property
170
172
  @pulumi.getter(name="ingestType")
171
- def ingest_type(self) -> Optional[pulumi.Input[builtins.str]]:
173
+ def ingest_type(self) -> Optional[pulumi.Input[_builtins.str]]:
172
174
  """
173
- Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
175
+ Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
174
176
  """
175
177
  return pulumi.get(self, "ingest_type")
176
178
 
177
179
  @ingest_type.setter
178
- def ingest_type(self, value: Optional[pulumi.Input[builtins.str]]):
180
+ def ingest_type(self, value: Optional[pulumi.Input[_builtins.str]]):
179
181
  pulumi.set(self, "ingest_type", value)
180
182
 
181
- @property
183
+ @_builtins.property
182
184
  @pulumi.getter
183
- def key(self) -> Optional[pulumi.Input[builtins.str]]:
185
+ def key(self) -> Optional[pulumi.Input[_builtins.str]]:
184
186
  """
185
- The actual API key. This attribute is masked and not be visible in your terminal, CI, etc.
187
+ The actual API key.
188
+ - <span style="color:tomato;">It is important to exercise caution when exporting the value of `key`, as it is sensitive information</span>. Avoid logging or exposing it inappropriately.
186
189
  """
187
190
  return pulumi.get(self, "key")
188
191
 
189
192
  @key.setter
190
- def key(self, value: Optional[pulumi.Input[builtins.str]]):
193
+ def key(self, value: Optional[pulumi.Input[_builtins.str]]):
191
194
  pulumi.set(self, "key", value)
192
195
 
193
- @property
196
+ @_builtins.property
194
197
  @pulumi.getter(name="keyType")
195
- def key_type(self) -> Optional[pulumi.Input[builtins.str]]:
198
+ def key_type(self) -> Optional[pulumi.Input[_builtins.str]]:
196
199
  """
197
- What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
200
+ The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
201
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
202
+ - If `key_type` is `USER`, then `user_id` must be specified.
198
203
  """
199
204
  return pulumi.get(self, "key_type")
200
205
 
201
206
  @key_type.setter
202
- def key_type(self, value: Optional[pulumi.Input[builtins.str]]):
207
+ def key_type(self, value: Optional[pulumi.Input[_builtins.str]]):
203
208
  pulumi.set(self, "key_type", value)
204
209
 
205
- @property
210
+ @_builtins.property
206
211
  @pulumi.getter
207
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
208
- """
209
- The name of the key.
210
- """
212
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
211
213
  return pulumi.get(self, "name")
212
214
 
213
215
  @name.setter
214
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
216
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
215
217
  pulumi.set(self, "name", value)
216
218
 
217
- @property
219
+ @_builtins.property
218
220
  @pulumi.getter
219
- def notes(self) -> Optional[pulumi.Input[builtins.str]]:
221
+ def notes(self) -> Optional[pulumi.Input[_builtins.str]]:
220
222
  """
221
- Any notes about this ingest key.
223
+ Additional notes about the API access key.
222
224
  """
223
225
  return pulumi.get(self, "notes")
224
226
 
225
227
  @notes.setter
226
- def notes(self, value: Optional[pulumi.Input[builtins.str]]):
228
+ def notes(self, value: Optional[pulumi.Input[_builtins.str]]):
227
229
  pulumi.set(self, "notes", value)
228
230
 
229
- @property
231
+ @_builtins.property
230
232
  @pulumi.getter(name="userId")
231
- def user_id(self) -> Optional[pulumi.Input[builtins.str]]:
233
+ def user_id(self) -> Optional[pulumi.Input[_builtins.str]]:
232
234
  """
233
- Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
235
+ Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
234
236
  """
235
237
  return pulumi.get(self, "user_id")
236
238
 
237
239
  @user_id.setter
238
- def user_id(self, value: Optional[pulumi.Input[builtins.str]]):
240
+ def user_id(self, value: Optional[pulumi.Input[_builtins.str]]):
239
241
  pulumi.set(self, "user_id", value)
240
242
 
241
243
 
@@ -245,33 +247,49 @@ class ApiAccessKey(pulumi.CustomResource):
245
247
  def __init__(__self__,
246
248
  resource_name: str,
247
249
  opts: Optional[pulumi.ResourceOptions] = None,
248
- account_id: Optional[pulumi.Input[builtins.str]] = None,
249
- ingest_type: Optional[pulumi.Input[builtins.str]] = None,
250
- key_type: Optional[pulumi.Input[builtins.str]] = None,
251
- name: Optional[pulumi.Input[builtins.str]] = None,
252
- notes: Optional[pulumi.Input[builtins.str]] = None,
253
- user_id: Optional[pulumi.Input[builtins.str]] = None,
250
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
251
+ ingest_type: Optional[pulumi.Input[_builtins.str]] = None,
252
+ key_type: Optional[pulumi.Input[_builtins.str]] = None,
253
+ name: Optional[pulumi.Input[_builtins.str]] = None,
254
+ notes: Optional[pulumi.Input[_builtins.str]] = None,
255
+ user_id: Optional[pulumi.Input[_builtins.str]] = None,
254
256
  __props__=None):
255
257
  """
256
258
  ## Import
257
259
 
258
- Existing API access keys can be imported using a composite ID of `<api_access_key_id>:<key_type>`. `<key_type>`
259
- will be either `INGEST` or `USER`.
260
+ Existing API access keys can be imported using a composite ID of `<api_access_key_id>:<key_type>`, where `<key_type>` is either `INGEST` or `USER`. Refer to the considerations listed in the Important Considerations section above regarding limitations on importing the actual key value.
260
261
 
261
262
  For example:
262
263
 
263
264
  ```sh
264
- $ pulumi import newrelic:index/apiAccessKey:ApiAccessKey foobar "1234567:INGEST"
265
+ $ pulumi import newrelic:index/apiAccessKey:ApiAccessKey foobar "131313133A331313130B5F13DF01313FDB13B13133EE5E133D13EAAB3A3C13D3:INGEST"
265
266
  ```
266
267
 
268
+ For customers using Terraform v1.5 and above, it is recommended to use the `import {}` block in your Terraform configuration. This allows Terraform to generate the resource configuration automatically during the import process by running a `pulumi preview -generate-config-out=<filename>.tf`, reducing manual effort and ensuring accuracy.
269
+
270
+ For example:
271
+
272
+ hcl
273
+
274
+ import {
275
+
276
+ id = "131313133A331313130B5F13DF01313FDB13B13133EE5E133D13EAAB3A3C13D3:INGEST"
277
+
278
+ to = newrelic_api_access_key.foobar
279
+
280
+ }
281
+
282
+ This approach simplifies the import process and ensures that the resource configuration aligns with the imported state.
283
+
267
284
  :param str resource_name: The name of the resource.
268
285
  :param pulumi.ResourceOptions opts: Options for the resource.
269
- :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the API access key.
270
- :param pulumi.Input[builtins.str] ingest_type: Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
271
- :param pulumi.Input[builtins.str] key_type: What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
272
- :param pulumi.Input[builtins.str] name: The name of the key.
273
- :param pulumi.Input[builtins.str] notes: Any notes about this ingest key.
274
- :param pulumi.Input[builtins.str] user_id: Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
286
+ :param pulumi.Input[_builtins.str] account_id: The New Relic account ID where the API access key will be created.
287
+ :param pulumi.Input[_builtins.str] ingest_type: Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
288
+ :param pulumi.Input[_builtins.str] key_type: The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
289
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
290
+ - If `key_type` is `USER`, then `user_id` must be specified.
291
+ :param pulumi.Input[_builtins.str] notes: Additional notes about the API access key.
292
+ :param pulumi.Input[_builtins.str] user_id: Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
275
293
  """
276
294
  ...
277
295
  @overload
@@ -282,15 +300,30 @@ class ApiAccessKey(pulumi.CustomResource):
282
300
  """
283
301
  ## Import
284
302
 
285
- Existing API access keys can be imported using a composite ID of `<api_access_key_id>:<key_type>`. `<key_type>`
286
- will be either `INGEST` or `USER`.
303
+ Existing API access keys can be imported using a composite ID of `<api_access_key_id>:<key_type>`, where `<key_type>` is either `INGEST` or `USER`. Refer to the considerations listed in the Important Considerations section above regarding limitations on importing the actual key value.
287
304
 
288
305
  For example:
289
306
 
290
307
  ```sh
291
- $ pulumi import newrelic:index/apiAccessKey:ApiAccessKey foobar "1234567:INGEST"
308
+ $ pulumi import newrelic:index/apiAccessKey:ApiAccessKey foobar "131313133A331313130B5F13DF01313FDB13B13133EE5E133D13EAAB3A3C13D3:INGEST"
292
309
  ```
293
310
 
311
+ For customers using Terraform v1.5 and above, it is recommended to use the `import {}` block in your Terraform configuration. This allows Terraform to generate the resource configuration automatically during the import process by running a `pulumi preview -generate-config-out=<filename>.tf`, reducing manual effort and ensuring accuracy.
312
+
313
+ For example:
314
+
315
+ hcl
316
+
317
+ import {
318
+
319
+ id = "131313133A331313130B5F13DF01313FDB13B13133EE5E133D13EAAB3A3C13D3:INGEST"
320
+
321
+ to = newrelic_api_access_key.foobar
322
+
323
+ }
324
+
325
+ This approach simplifies the import process and ensures that the resource configuration aligns with the imported state.
326
+
294
327
  :param str resource_name: The name of the resource.
295
328
  :param ApiAccessKeyArgs args: The arguments to use to populate this resource's properties.
296
329
  :param pulumi.ResourceOptions opts: Options for the resource.
@@ -306,12 +339,12 @@ class ApiAccessKey(pulumi.CustomResource):
306
339
  def _internal_init(__self__,
307
340
  resource_name: str,
308
341
  opts: Optional[pulumi.ResourceOptions] = None,
309
- account_id: Optional[pulumi.Input[builtins.str]] = None,
310
- ingest_type: Optional[pulumi.Input[builtins.str]] = None,
311
- key_type: Optional[pulumi.Input[builtins.str]] = None,
312
- name: Optional[pulumi.Input[builtins.str]] = None,
313
- notes: Optional[pulumi.Input[builtins.str]] = None,
314
- user_id: Optional[pulumi.Input[builtins.str]] = None,
342
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
343
+ ingest_type: Optional[pulumi.Input[_builtins.str]] = None,
344
+ key_type: Optional[pulumi.Input[_builtins.str]] = None,
345
+ name: Optional[pulumi.Input[_builtins.str]] = None,
346
+ notes: Optional[pulumi.Input[_builtins.str]] = None,
347
+ user_id: Optional[pulumi.Input[_builtins.str]] = None,
315
348
  __props__=None):
316
349
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
317
350
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -321,8 +354,6 @@ class ApiAccessKey(pulumi.CustomResource):
321
354
  raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
322
355
  __props__ = ApiAccessKeyArgs.__new__(ApiAccessKeyArgs)
323
356
 
324
- if account_id is None and not opts.urn:
325
- raise TypeError("Missing required property 'account_id'")
326
357
  __props__.__dict__["account_id"] = account_id
327
358
  __props__.__dict__["ingest_type"] = ingest_type
328
359
  if key_type is None and not opts.urn:
@@ -332,8 +363,6 @@ class ApiAccessKey(pulumi.CustomResource):
332
363
  __props__.__dict__["notes"] = notes
333
364
  __props__.__dict__["user_id"] = user_id
334
365
  __props__.__dict__["key"] = None
335
- secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["key"])
336
- opts = pulumi.ResourceOptions.merge(opts, secret_opts)
337
366
  super(ApiAccessKey, __self__).__init__(
338
367
  'newrelic:index/apiAccessKey:ApiAccessKey',
339
368
  resource_name,
@@ -344,13 +373,13 @@ class ApiAccessKey(pulumi.CustomResource):
344
373
  def get(resource_name: str,
345
374
  id: pulumi.Input[str],
346
375
  opts: Optional[pulumi.ResourceOptions] = None,
347
- account_id: Optional[pulumi.Input[builtins.str]] = None,
348
- ingest_type: Optional[pulumi.Input[builtins.str]] = None,
349
- key: Optional[pulumi.Input[builtins.str]] = None,
350
- key_type: Optional[pulumi.Input[builtins.str]] = None,
351
- name: Optional[pulumi.Input[builtins.str]] = None,
352
- notes: Optional[pulumi.Input[builtins.str]] = None,
353
- user_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ApiAccessKey':
376
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
377
+ ingest_type: Optional[pulumi.Input[_builtins.str]] = None,
378
+ key: Optional[pulumi.Input[_builtins.str]] = None,
379
+ key_type: Optional[pulumi.Input[_builtins.str]] = None,
380
+ name: Optional[pulumi.Input[_builtins.str]] = None,
381
+ notes: Optional[pulumi.Input[_builtins.str]] = None,
382
+ user_id: Optional[pulumi.Input[_builtins.str]] = None) -> 'ApiAccessKey':
354
383
  """
355
384
  Get an existing ApiAccessKey resource's state with the given name, id, and optional extra
356
385
  properties used to qualify the lookup.
@@ -358,13 +387,15 @@ class ApiAccessKey(pulumi.CustomResource):
358
387
  :param str resource_name: The unique name of the resulting resource.
359
388
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
360
389
  :param pulumi.ResourceOptions opts: Options for the resource.
361
- :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the API access key.
362
- :param pulumi.Input[builtins.str] ingest_type: Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
363
- :param pulumi.Input[builtins.str] key: The actual API key. This attribute is masked and not be visible in your terminal, CI, etc.
364
- :param pulumi.Input[builtins.str] key_type: What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
365
- :param pulumi.Input[builtins.str] name: The name of the key.
366
- :param pulumi.Input[builtins.str] notes: Any notes about this ingest key.
367
- :param pulumi.Input[builtins.str] user_id: Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
390
+ :param pulumi.Input[_builtins.str] account_id: The New Relic account ID where the API access key will be created.
391
+ :param pulumi.Input[_builtins.str] ingest_type: Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
392
+ :param pulumi.Input[_builtins.str] key: The actual API key.
393
+ - <span style="color:tomato;">It is important to exercise caution when exporting the value of `key`, as it is sensitive information</span>. Avoid logging or exposing it inappropriately.
394
+ :param pulumi.Input[_builtins.str] key_type: The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
395
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
396
+ - If `key_type` is `USER`, then `user_id` must be specified.
397
+ :param pulumi.Input[_builtins.str] notes: Additional notes about the API access key.
398
+ :param pulumi.Input[_builtins.str] user_id: Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
368
399
  """
369
400
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
370
401
 
@@ -379,59 +410,59 @@ class ApiAccessKey(pulumi.CustomResource):
379
410
  __props__.__dict__["user_id"] = user_id
380
411
  return ApiAccessKey(resource_name, opts=opts, __props__=__props__)
381
412
 
382
- @property
413
+ @_builtins.property
383
414
  @pulumi.getter(name="accountId")
384
- def account_id(self) -> pulumi.Output[builtins.str]:
415
+ def account_id(self) -> pulumi.Output[Optional[_builtins.str]]:
385
416
  """
386
- The New Relic account ID of the account you wish to create the API access key.
417
+ The New Relic account ID where the API access key will be created.
387
418
  """
388
419
  return pulumi.get(self, "account_id")
389
420
 
390
- @property
421
+ @_builtins.property
391
422
  @pulumi.getter(name="ingestType")
392
- def ingest_type(self) -> pulumi.Output[builtins.str]:
423
+ def ingest_type(self) -> pulumi.Output[_builtins.str]:
393
424
  """
394
- Required if `key_type = INGEST`. Valid options are `BROWSER` or `LICENSE`, case-sensitive.
425
+ Required if `key_type` is `INGEST`. Valid options are `BROWSER` or `LICENSE` (case-sensitive).
395
426
  """
396
427
  return pulumi.get(self, "ingest_type")
397
428
 
398
- @property
429
+ @_builtins.property
399
430
  @pulumi.getter
400
- def key(self) -> pulumi.Output[builtins.str]:
431
+ def key(self) -> pulumi.Output[_builtins.str]:
401
432
  """
402
- The actual API key. This attribute is masked and not be visible in your terminal, CI, etc.
433
+ The actual API key.
434
+ - <span style="color:tomato;">It is important to exercise caution when exporting the value of `key`, as it is sensitive information</span>. Avoid logging or exposing it inappropriately.
403
435
  """
404
436
  return pulumi.get(self, "key")
405
437
 
406
- @property
438
+ @_builtins.property
407
439
  @pulumi.getter(name="keyType")
408
- def key_type(self) -> pulumi.Output[builtins.str]:
440
+ def key_type(self) -> pulumi.Output[_builtins.str]:
409
441
  """
410
- What type of API key to create. Valid options are `INGEST` or `USER`, case-sensitive.
442
+ The type of API key to create. Valid options are `INGEST` or `USER` (case-sensitive).
443
+ - If `key_type` is `INGEST`, then `ingest_type` must be specified.
444
+ - If `key_type` is `USER`, then `user_id` must be specified.
411
445
  """
412
446
  return pulumi.get(self, "key_type")
413
447
 
414
- @property
448
+ @_builtins.property
415
449
  @pulumi.getter
416
- def name(self) -> pulumi.Output[builtins.str]:
417
- """
418
- The name of the key.
419
- """
450
+ def name(self) -> pulumi.Output[_builtins.str]:
420
451
  return pulumi.get(self, "name")
421
452
 
422
- @property
453
+ @_builtins.property
423
454
  @pulumi.getter
424
- def notes(self) -> pulumi.Output[builtins.str]:
455
+ def notes(self) -> pulumi.Output[_builtins.str]:
425
456
  """
426
- Any notes about this ingest key.
457
+ Additional notes about the API access key.
427
458
  """
428
459
  return pulumi.get(self, "notes")
429
460
 
430
- @property
461
+ @_builtins.property
431
462
  @pulumi.getter(name="userId")
432
- def user_id(self) -> pulumi.Output[builtins.str]:
463
+ def user_id(self) -> pulumi.Output[_builtins.str]:
433
464
  """
434
- Required if `key_type = USER`. The New Relic user ID yous wish to create the API access key for in an account.
465
+ Required if `key_type` is `USER`. The New Relic user ID for which the API access key will be created.
435
466
  """
436
467
  return pulumi.get(self, "user_id")
437
468