pulumi-newrelic 5.34.0a1728366646__py3-none-any.whl → 5.34.0a1728941524__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_newrelic/_inputs.py +4147 -78
- pulumi_newrelic/_utilities.py +1 -1
- pulumi_newrelic/account_management.py +5 -0
- pulumi_newrelic/alert_channel.py +5 -0
- pulumi_newrelic/alert_condition.py +5 -0
- pulumi_newrelic/alert_muting_rule.py +5 -0
- pulumi_newrelic/alert_policy.py +5 -0
- pulumi_newrelic/alert_policy_channel.py +5 -0
- pulumi_newrelic/api_access_key.py +5 -0
- pulumi_newrelic/browser_application.py +5 -0
- pulumi_newrelic/cloud/_inputs.py +2206 -11
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +5 -0
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +5 -0
- pulumi_newrelic/cloud/aws_integrations.py +5 -0
- pulumi_newrelic/cloud/aws_link_account.py +5 -0
- pulumi_newrelic/cloud/azure_integrations.py +5 -0
- pulumi_newrelic/cloud/azure_link_account.py +5 -0
- pulumi_newrelic/cloud/gcp_integrations.py +5 -0
- pulumi_newrelic/cloud/gcp_link_account.py +5 -0
- pulumi_newrelic/cloud/outputs.py +5 -0
- pulumi_newrelic/config/__init__.pyi +5 -0
- pulumi_newrelic/config/vars.py +5 -0
- pulumi_newrelic/data_partition_rule.py +5 -0
- pulumi_newrelic/entity_tags.py +5 -0
- pulumi_newrelic/events_to_metrics_rule.py +5 -0
- pulumi_newrelic/get_account.py +16 -4
- pulumi_newrelic/get_alert_channel.py +17 -4
- pulumi_newrelic/get_alert_policy.py +18 -4
- pulumi_newrelic/get_application.py +14 -4
- pulumi_newrelic/get_authentication_domain.py +12 -4
- pulumi_newrelic/get_cloud_account.py +16 -4
- pulumi_newrelic/get_entity.py +29 -4
- pulumi_newrelic/get_group.py +15 -4
- pulumi_newrelic/get_key_transaction.py +72 -9
- pulumi_newrelic/get_notification_destination.py +22 -4
- pulumi_newrelic/get_obfuscation_expression.py +14 -4
- pulumi_newrelic/get_service_level_alert_helper.py +28 -4
- pulumi_newrelic/get_test_grok_pattern.py +17 -4
- pulumi_newrelic/get_user.py +16 -4
- pulumi_newrelic/group.py +5 -0
- pulumi_newrelic/infra_alert_condition.py +5 -0
- pulumi_newrelic/insights/_inputs.py +43 -0
- pulumi_newrelic/insights/event.py +5 -0
- pulumi_newrelic/insights/outputs.py +5 -0
- pulumi_newrelic/key_transaction.py +5 -0
- pulumi_newrelic/log_parsing_rule.py +5 -0
- pulumi_newrelic/monitor_downtime.py +5 -0
- pulumi_newrelic/notification_channel.py +5 -0
- pulumi_newrelic/notification_destination.py +5 -0
- pulumi_newrelic/nrql_alert_condition.py +5 -0
- pulumi_newrelic/nrql_drop_rule.py +5 -0
- pulumi_newrelic/obfuscation_expression.py +5 -0
- pulumi_newrelic/obfuscation_rule.py +5 -0
- pulumi_newrelic/one_dashboard.py +5 -0
- pulumi_newrelic/one_dashboard_json.py +5 -0
- pulumi_newrelic/one_dashboard_raw.py +5 -0
- pulumi_newrelic/outputs.py +5 -0
- pulumi_newrelic/plugins/_inputs.py +135 -0
- pulumi_newrelic/plugins/application_settings.py +5 -0
- pulumi_newrelic/plugins/outputs.py +5 -0
- pulumi_newrelic/plugins/workload.py +5 -0
- pulumi_newrelic/provider.py +5 -0
- pulumi_newrelic/pulumi-plugin.json +1 -1
- pulumi_newrelic/service_level.py +5 -0
- pulumi_newrelic/synthetics/_inputs.py +157 -0
- pulumi_newrelic/synthetics/alert_condition.py +5 -0
- pulumi_newrelic/synthetics/broken_links_monitor.py +5 -0
- pulumi_newrelic/synthetics/cert_check_monitor.py +5 -0
- pulumi_newrelic/synthetics/get_private_location.py +16 -4
- pulumi_newrelic/synthetics/get_secure_credential.py +16 -4
- pulumi_newrelic/synthetics/monitor.py +5 -0
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +5 -0
- pulumi_newrelic/synthetics/outputs.py +5 -0
- pulumi_newrelic/synthetics/private_location.py +5 -0
- pulumi_newrelic/synthetics/script_monitor.py +5 -0
- pulumi_newrelic/synthetics/secure_credential.py +5 -0
- pulumi_newrelic/synthetics/step_monitor.py +5 -0
- pulumi_newrelic/user.py +5 -0
- pulumi_newrelic/workflow.py +5 -0
- {pulumi_newrelic-5.34.0a1728366646.dist-info → pulumi_newrelic-5.34.0a1728941524.dist-info}/METADATA +3 -2
- pulumi_newrelic-5.34.0a1728941524.dist-info/RECORD +90 -0
- pulumi_newrelic-5.34.0a1728366646.dist-info/RECORD +0 -90
- {pulumi_newrelic-5.34.0a1728366646.dist-info → pulumi_newrelic-5.34.0a1728941524.dist-info}/WHEEL +0 -0
- {pulumi_newrelic-5.34.0a1728366646.dist-info → pulumi_newrelic-5.34.0a1728941524.dist-info}/top_level.txt +0 -0
pulumi_newrelic/cloud/_inputs.py
CHANGED
|
@@ -4,144 +4,314 @@
|
|
|
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
|
'AwsGovcloudIntegrationsAlbArgs',
|
|
19
|
+
'AwsGovcloudIntegrationsAlbArgsDict',
|
|
14
20
|
'AwsGovcloudIntegrationsApiGatewayArgs',
|
|
21
|
+
'AwsGovcloudIntegrationsApiGatewayArgsDict',
|
|
15
22
|
'AwsGovcloudIntegrationsAutoScalingArgs',
|
|
23
|
+
'AwsGovcloudIntegrationsAutoScalingArgsDict',
|
|
16
24
|
'AwsGovcloudIntegrationsAwsDirectConnectArgs',
|
|
25
|
+
'AwsGovcloudIntegrationsAwsDirectConnectArgsDict',
|
|
17
26
|
'AwsGovcloudIntegrationsAwsStatesArgs',
|
|
27
|
+
'AwsGovcloudIntegrationsAwsStatesArgsDict',
|
|
18
28
|
'AwsGovcloudIntegrationsCloudtrailArgs',
|
|
29
|
+
'AwsGovcloudIntegrationsCloudtrailArgsDict',
|
|
19
30
|
'AwsGovcloudIntegrationsDynamoDbArgs',
|
|
31
|
+
'AwsGovcloudIntegrationsDynamoDbArgsDict',
|
|
20
32
|
'AwsGovcloudIntegrationsEbsArgs',
|
|
33
|
+
'AwsGovcloudIntegrationsEbsArgsDict',
|
|
21
34
|
'AwsGovcloudIntegrationsEc2Args',
|
|
35
|
+
'AwsGovcloudIntegrationsEc2ArgsDict',
|
|
22
36
|
'AwsGovcloudIntegrationsElasticSearchArgs',
|
|
37
|
+
'AwsGovcloudIntegrationsElasticSearchArgsDict',
|
|
23
38
|
'AwsGovcloudIntegrationsElbArgs',
|
|
39
|
+
'AwsGovcloudIntegrationsElbArgsDict',
|
|
24
40
|
'AwsGovcloudIntegrationsEmrArgs',
|
|
41
|
+
'AwsGovcloudIntegrationsEmrArgsDict',
|
|
25
42
|
'AwsGovcloudIntegrationsIamArgs',
|
|
43
|
+
'AwsGovcloudIntegrationsIamArgsDict',
|
|
26
44
|
'AwsGovcloudIntegrationsLambdaArgs',
|
|
45
|
+
'AwsGovcloudIntegrationsLambdaArgsDict',
|
|
27
46
|
'AwsGovcloudIntegrationsRdsArgs',
|
|
47
|
+
'AwsGovcloudIntegrationsRdsArgsDict',
|
|
28
48
|
'AwsGovcloudIntegrationsRedShiftArgs',
|
|
49
|
+
'AwsGovcloudIntegrationsRedShiftArgsDict',
|
|
29
50
|
'AwsGovcloudIntegrationsRoute53Args',
|
|
51
|
+
'AwsGovcloudIntegrationsRoute53ArgsDict',
|
|
30
52
|
'AwsGovcloudIntegrationsS3Args',
|
|
53
|
+
'AwsGovcloudIntegrationsS3ArgsDict',
|
|
31
54
|
'AwsGovcloudIntegrationsSnsArgs',
|
|
55
|
+
'AwsGovcloudIntegrationsSnsArgsDict',
|
|
32
56
|
'AwsGovcloudIntegrationsSqsArgs',
|
|
57
|
+
'AwsGovcloudIntegrationsSqsArgsDict',
|
|
33
58
|
'AwsIntegrationsAlbArgs',
|
|
59
|
+
'AwsIntegrationsAlbArgsDict',
|
|
34
60
|
'AwsIntegrationsApiGatewayArgs',
|
|
61
|
+
'AwsIntegrationsApiGatewayArgsDict',
|
|
35
62
|
'AwsIntegrationsAutoScalingArgs',
|
|
63
|
+
'AwsIntegrationsAutoScalingArgsDict',
|
|
36
64
|
'AwsIntegrationsAwsAppSyncArgs',
|
|
65
|
+
'AwsIntegrationsAwsAppSyncArgsDict',
|
|
37
66
|
'AwsIntegrationsAwsAthenaArgs',
|
|
67
|
+
'AwsIntegrationsAwsAthenaArgsDict',
|
|
38
68
|
'AwsIntegrationsAwsCognitoArgs',
|
|
69
|
+
'AwsIntegrationsAwsCognitoArgsDict',
|
|
39
70
|
'AwsIntegrationsAwsConnectArgs',
|
|
71
|
+
'AwsIntegrationsAwsConnectArgsDict',
|
|
40
72
|
'AwsIntegrationsAwsDirectConnectArgs',
|
|
73
|
+
'AwsIntegrationsAwsDirectConnectArgsDict',
|
|
41
74
|
'AwsIntegrationsAwsFsxArgs',
|
|
75
|
+
'AwsIntegrationsAwsFsxArgsDict',
|
|
42
76
|
'AwsIntegrationsAwsGlueArgs',
|
|
77
|
+
'AwsIntegrationsAwsGlueArgsDict',
|
|
43
78
|
'AwsIntegrationsAwsKinesisAnalyticsArgs',
|
|
79
|
+
'AwsIntegrationsAwsKinesisAnalyticsArgsDict',
|
|
44
80
|
'AwsIntegrationsAwsMediaConvertArgs',
|
|
81
|
+
'AwsIntegrationsAwsMediaConvertArgsDict',
|
|
45
82
|
'AwsIntegrationsAwsMediaPackageVodArgs',
|
|
83
|
+
'AwsIntegrationsAwsMediaPackageVodArgsDict',
|
|
46
84
|
'AwsIntegrationsAwsMqArgs',
|
|
85
|
+
'AwsIntegrationsAwsMqArgsDict',
|
|
47
86
|
'AwsIntegrationsAwsMskArgs',
|
|
87
|
+
'AwsIntegrationsAwsMskArgsDict',
|
|
48
88
|
'AwsIntegrationsAwsNeptuneArgs',
|
|
89
|
+
'AwsIntegrationsAwsNeptuneArgsDict',
|
|
49
90
|
'AwsIntegrationsAwsQldbArgs',
|
|
91
|
+
'AwsIntegrationsAwsQldbArgsDict',
|
|
50
92
|
'AwsIntegrationsAwsRoute53resolverArgs',
|
|
93
|
+
'AwsIntegrationsAwsRoute53resolverArgsDict',
|
|
51
94
|
'AwsIntegrationsAwsStatesArgs',
|
|
95
|
+
'AwsIntegrationsAwsStatesArgsDict',
|
|
52
96
|
'AwsIntegrationsAwsTransitGatewayArgs',
|
|
97
|
+
'AwsIntegrationsAwsTransitGatewayArgsDict',
|
|
53
98
|
'AwsIntegrationsAwsWafArgs',
|
|
99
|
+
'AwsIntegrationsAwsWafArgsDict',
|
|
54
100
|
'AwsIntegrationsAwsWafv2Args',
|
|
101
|
+
'AwsIntegrationsAwsWafv2ArgsDict',
|
|
55
102
|
'AwsIntegrationsBillingArgs',
|
|
103
|
+
'AwsIntegrationsBillingArgsDict',
|
|
56
104
|
'AwsIntegrationsCloudfrontArgs',
|
|
105
|
+
'AwsIntegrationsCloudfrontArgsDict',
|
|
57
106
|
'AwsIntegrationsCloudtrailArgs',
|
|
107
|
+
'AwsIntegrationsCloudtrailArgsDict',
|
|
58
108
|
'AwsIntegrationsDocDbArgs',
|
|
109
|
+
'AwsIntegrationsDocDbArgsDict',
|
|
59
110
|
'AwsIntegrationsDynamodbArgs',
|
|
111
|
+
'AwsIntegrationsDynamodbArgsDict',
|
|
60
112
|
'AwsIntegrationsEbsArgs',
|
|
113
|
+
'AwsIntegrationsEbsArgsDict',
|
|
61
114
|
'AwsIntegrationsEc2Args',
|
|
115
|
+
'AwsIntegrationsEc2ArgsDict',
|
|
62
116
|
'AwsIntegrationsEcsArgs',
|
|
117
|
+
'AwsIntegrationsEcsArgsDict',
|
|
63
118
|
'AwsIntegrationsEfsArgs',
|
|
119
|
+
'AwsIntegrationsEfsArgsDict',
|
|
64
120
|
'AwsIntegrationsElasticacheArgs',
|
|
121
|
+
'AwsIntegrationsElasticacheArgsDict',
|
|
65
122
|
'AwsIntegrationsElasticbeanstalkArgs',
|
|
123
|
+
'AwsIntegrationsElasticbeanstalkArgsDict',
|
|
66
124
|
'AwsIntegrationsElasticsearchArgs',
|
|
125
|
+
'AwsIntegrationsElasticsearchArgsDict',
|
|
67
126
|
'AwsIntegrationsElbArgs',
|
|
127
|
+
'AwsIntegrationsElbArgsDict',
|
|
68
128
|
'AwsIntegrationsEmrArgs',
|
|
129
|
+
'AwsIntegrationsEmrArgsDict',
|
|
69
130
|
'AwsIntegrationsHealthArgs',
|
|
131
|
+
'AwsIntegrationsHealthArgsDict',
|
|
70
132
|
'AwsIntegrationsIamArgs',
|
|
133
|
+
'AwsIntegrationsIamArgsDict',
|
|
71
134
|
'AwsIntegrationsIotArgs',
|
|
135
|
+
'AwsIntegrationsIotArgsDict',
|
|
72
136
|
'AwsIntegrationsKinesisArgs',
|
|
137
|
+
'AwsIntegrationsKinesisArgsDict',
|
|
73
138
|
'AwsIntegrationsKinesisFirehoseArgs',
|
|
139
|
+
'AwsIntegrationsKinesisFirehoseArgsDict',
|
|
74
140
|
'AwsIntegrationsLambdaArgs',
|
|
141
|
+
'AwsIntegrationsLambdaArgsDict',
|
|
75
142
|
'AwsIntegrationsRdsArgs',
|
|
143
|
+
'AwsIntegrationsRdsArgsDict',
|
|
76
144
|
'AwsIntegrationsRedshiftArgs',
|
|
145
|
+
'AwsIntegrationsRedshiftArgsDict',
|
|
77
146
|
'AwsIntegrationsRoute53Args',
|
|
147
|
+
'AwsIntegrationsRoute53ArgsDict',
|
|
78
148
|
'AwsIntegrationsS3Args',
|
|
149
|
+
'AwsIntegrationsS3ArgsDict',
|
|
79
150
|
'AwsIntegrationsSesArgs',
|
|
151
|
+
'AwsIntegrationsSesArgsDict',
|
|
80
152
|
'AwsIntegrationsSnsArgs',
|
|
153
|
+
'AwsIntegrationsSnsArgsDict',
|
|
81
154
|
'AwsIntegrationsSqsArgs',
|
|
155
|
+
'AwsIntegrationsSqsArgsDict',
|
|
82
156
|
'AwsIntegrationsTrustedAdvisorArgs',
|
|
157
|
+
'AwsIntegrationsTrustedAdvisorArgsDict',
|
|
83
158
|
'AwsIntegrationsVpcArgs',
|
|
159
|
+
'AwsIntegrationsVpcArgsDict',
|
|
84
160
|
'AwsIntegrationsXRayArgs',
|
|
161
|
+
'AwsIntegrationsXRayArgsDict',
|
|
85
162
|
'AzureIntegrationsApiManagementArgs',
|
|
163
|
+
'AzureIntegrationsApiManagementArgsDict',
|
|
86
164
|
'AzureIntegrationsAppGatewayArgs',
|
|
165
|
+
'AzureIntegrationsAppGatewayArgsDict',
|
|
87
166
|
'AzureIntegrationsAppServiceArgs',
|
|
167
|
+
'AzureIntegrationsAppServiceArgsDict',
|
|
88
168
|
'AzureIntegrationsContainersArgs',
|
|
169
|
+
'AzureIntegrationsContainersArgsDict',
|
|
89
170
|
'AzureIntegrationsCosmosDbArgs',
|
|
171
|
+
'AzureIntegrationsCosmosDbArgsDict',
|
|
90
172
|
'AzureIntegrationsCostManagementArgs',
|
|
173
|
+
'AzureIntegrationsCostManagementArgsDict',
|
|
91
174
|
'AzureIntegrationsDataFactoryArgs',
|
|
175
|
+
'AzureIntegrationsDataFactoryArgsDict',
|
|
92
176
|
'AzureIntegrationsEventHubArgs',
|
|
177
|
+
'AzureIntegrationsEventHubArgsDict',
|
|
93
178
|
'AzureIntegrationsExpressRouteArgs',
|
|
179
|
+
'AzureIntegrationsExpressRouteArgsDict',
|
|
94
180
|
'AzureIntegrationsFirewallsArgs',
|
|
181
|
+
'AzureIntegrationsFirewallsArgsDict',
|
|
95
182
|
'AzureIntegrationsFrontDoorArgs',
|
|
183
|
+
'AzureIntegrationsFrontDoorArgsDict',
|
|
96
184
|
'AzureIntegrationsFunctionsArgs',
|
|
185
|
+
'AzureIntegrationsFunctionsArgsDict',
|
|
97
186
|
'AzureIntegrationsKeyVaultArgs',
|
|
187
|
+
'AzureIntegrationsKeyVaultArgsDict',
|
|
98
188
|
'AzureIntegrationsLoadBalancerArgs',
|
|
189
|
+
'AzureIntegrationsLoadBalancerArgsDict',
|
|
99
190
|
'AzureIntegrationsLogicAppsArgs',
|
|
191
|
+
'AzureIntegrationsLogicAppsArgsDict',
|
|
100
192
|
'AzureIntegrationsMachineLearningArgs',
|
|
193
|
+
'AzureIntegrationsMachineLearningArgsDict',
|
|
101
194
|
'AzureIntegrationsMariaDbArgs',
|
|
195
|
+
'AzureIntegrationsMariaDbArgsDict',
|
|
102
196
|
'AzureIntegrationsMonitorArgs',
|
|
197
|
+
'AzureIntegrationsMonitorArgsDict',
|
|
103
198
|
'AzureIntegrationsMysqlArgs',
|
|
199
|
+
'AzureIntegrationsMysqlArgsDict',
|
|
104
200
|
'AzureIntegrationsMysqlFlexibleArgs',
|
|
201
|
+
'AzureIntegrationsMysqlFlexibleArgsDict',
|
|
105
202
|
'AzureIntegrationsPostgresqlArgs',
|
|
203
|
+
'AzureIntegrationsPostgresqlArgsDict',
|
|
106
204
|
'AzureIntegrationsPostgresqlFlexibleArgs',
|
|
205
|
+
'AzureIntegrationsPostgresqlFlexibleArgsDict',
|
|
107
206
|
'AzureIntegrationsPowerBiDedicatedArgs',
|
|
207
|
+
'AzureIntegrationsPowerBiDedicatedArgsDict',
|
|
108
208
|
'AzureIntegrationsRedisCacheArgs',
|
|
209
|
+
'AzureIntegrationsRedisCacheArgsDict',
|
|
109
210
|
'AzureIntegrationsServiceBusArgs',
|
|
211
|
+
'AzureIntegrationsServiceBusArgsDict',
|
|
110
212
|
'AzureIntegrationsSqlArgs',
|
|
213
|
+
'AzureIntegrationsSqlArgsDict',
|
|
111
214
|
'AzureIntegrationsSqlManagedArgs',
|
|
215
|
+
'AzureIntegrationsSqlManagedArgsDict',
|
|
112
216
|
'AzureIntegrationsStorageArgs',
|
|
217
|
+
'AzureIntegrationsStorageArgsDict',
|
|
113
218
|
'AzureIntegrationsVirtualMachineArgs',
|
|
219
|
+
'AzureIntegrationsVirtualMachineArgsDict',
|
|
114
220
|
'AzureIntegrationsVirtualNetworksArgs',
|
|
221
|
+
'AzureIntegrationsVirtualNetworksArgsDict',
|
|
115
222
|
'AzureIntegrationsVmsArgs',
|
|
223
|
+
'AzureIntegrationsVmsArgsDict',
|
|
116
224
|
'AzureIntegrationsVpnGatewayArgs',
|
|
225
|
+
'AzureIntegrationsVpnGatewayArgsDict',
|
|
117
226
|
'GcpIntegrationsAlloyDbArgs',
|
|
227
|
+
'GcpIntegrationsAlloyDbArgsDict',
|
|
118
228
|
'GcpIntegrationsAppEngineArgs',
|
|
229
|
+
'GcpIntegrationsAppEngineArgsDict',
|
|
119
230
|
'GcpIntegrationsBigQueryArgs',
|
|
231
|
+
'GcpIntegrationsBigQueryArgsDict',
|
|
120
232
|
'GcpIntegrationsBigTableArgs',
|
|
233
|
+
'GcpIntegrationsBigTableArgsDict',
|
|
121
234
|
'GcpIntegrationsComposerArgs',
|
|
235
|
+
'GcpIntegrationsComposerArgsDict',
|
|
122
236
|
'GcpIntegrationsDataFlowArgs',
|
|
237
|
+
'GcpIntegrationsDataFlowArgsDict',
|
|
123
238
|
'GcpIntegrationsDataProcArgs',
|
|
239
|
+
'GcpIntegrationsDataProcArgsDict',
|
|
124
240
|
'GcpIntegrationsDataStoreArgs',
|
|
241
|
+
'GcpIntegrationsDataStoreArgsDict',
|
|
125
242
|
'GcpIntegrationsFireBaseDatabaseArgs',
|
|
243
|
+
'GcpIntegrationsFireBaseDatabaseArgsDict',
|
|
126
244
|
'GcpIntegrationsFireBaseHostingArgs',
|
|
245
|
+
'GcpIntegrationsFireBaseHostingArgsDict',
|
|
127
246
|
'GcpIntegrationsFireBaseStorageArgs',
|
|
247
|
+
'GcpIntegrationsFireBaseStorageArgsDict',
|
|
128
248
|
'GcpIntegrationsFireStoreArgs',
|
|
249
|
+
'GcpIntegrationsFireStoreArgsDict',
|
|
129
250
|
'GcpIntegrationsFunctionsArgs',
|
|
251
|
+
'GcpIntegrationsFunctionsArgsDict',
|
|
130
252
|
'GcpIntegrationsInterconnectArgs',
|
|
253
|
+
'GcpIntegrationsInterconnectArgsDict',
|
|
131
254
|
'GcpIntegrationsKubernetesArgs',
|
|
255
|
+
'GcpIntegrationsKubernetesArgsDict',
|
|
132
256
|
'GcpIntegrationsLoadBalancingArgs',
|
|
257
|
+
'GcpIntegrationsLoadBalancingArgsDict',
|
|
133
258
|
'GcpIntegrationsMemCacheArgs',
|
|
259
|
+
'GcpIntegrationsMemCacheArgsDict',
|
|
134
260
|
'GcpIntegrationsPubSubArgs',
|
|
261
|
+
'GcpIntegrationsPubSubArgsDict',
|
|
135
262
|
'GcpIntegrationsRedisArgs',
|
|
263
|
+
'GcpIntegrationsRedisArgsDict',
|
|
136
264
|
'GcpIntegrationsRouterArgs',
|
|
265
|
+
'GcpIntegrationsRouterArgsDict',
|
|
137
266
|
'GcpIntegrationsRunArgs',
|
|
267
|
+
'GcpIntegrationsRunArgsDict',
|
|
138
268
|
'GcpIntegrationsSpannerArgs',
|
|
269
|
+
'GcpIntegrationsSpannerArgsDict',
|
|
139
270
|
'GcpIntegrationsSqlArgs',
|
|
271
|
+
'GcpIntegrationsSqlArgsDict',
|
|
140
272
|
'GcpIntegrationsStorageArgs',
|
|
273
|
+
'GcpIntegrationsStorageArgsDict',
|
|
141
274
|
'GcpIntegrationsVirtualMachinesArgs',
|
|
275
|
+
'GcpIntegrationsVirtualMachinesArgsDict',
|
|
142
276
|
'GcpIntegrationsVpcAccessArgs',
|
|
277
|
+
'GcpIntegrationsVpcAccessArgsDict',
|
|
143
278
|
]
|
|
144
279
|
|
|
280
|
+
MYPY = False
|
|
281
|
+
|
|
282
|
+
if not MYPY:
|
|
283
|
+
class AwsGovcloudIntegrationsAlbArgsDict(TypedDict):
|
|
284
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
285
|
+
"""
|
|
286
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
287
|
+
"""
|
|
288
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
289
|
+
"""
|
|
290
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
291
|
+
"""
|
|
292
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
293
|
+
"""
|
|
294
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
295
|
+
"""
|
|
296
|
+
load_balancer_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
297
|
+
"""
|
|
298
|
+
Specify each name or prefix for the LBs that you want to monitor. Filter values are case-sensitive.
|
|
299
|
+
"""
|
|
300
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
301
|
+
"""
|
|
302
|
+
The data polling interval in seconds
|
|
303
|
+
"""
|
|
304
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
305
|
+
"""
|
|
306
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
307
|
+
"""
|
|
308
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
309
|
+
"""
|
|
310
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
311
|
+
"""
|
|
312
|
+
elif False:
|
|
313
|
+
AwsGovcloudIntegrationsAlbArgsDict: TypeAlias = Mapping[str, Any]
|
|
314
|
+
|
|
145
315
|
@pulumi.input_type
|
|
146
316
|
class AwsGovcloudIntegrationsAlbArgs:
|
|
147
317
|
def __init__(__self__, *,
|
|
@@ -261,6 +431,31 @@ class AwsGovcloudIntegrationsAlbArgs:
|
|
|
261
431
|
pulumi.set(self, "tag_value", value)
|
|
262
432
|
|
|
263
433
|
|
|
434
|
+
if not MYPY:
|
|
435
|
+
class AwsGovcloudIntegrationsApiGatewayArgsDict(TypedDict):
|
|
436
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
437
|
+
"""
|
|
438
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
439
|
+
"""
|
|
440
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
441
|
+
"""
|
|
442
|
+
The data polling interval in seconds
|
|
443
|
+
"""
|
|
444
|
+
stage_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
445
|
+
"""
|
|
446
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
447
|
+
"""
|
|
448
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
449
|
+
"""
|
|
450
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
451
|
+
"""
|
|
452
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
453
|
+
"""
|
|
454
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
455
|
+
"""
|
|
456
|
+
elif False:
|
|
457
|
+
AwsGovcloudIntegrationsApiGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
458
|
+
|
|
264
459
|
@pulumi.input_type
|
|
265
460
|
class AwsGovcloudIntegrationsApiGatewayArgs:
|
|
266
461
|
def __init__(__self__, *,
|
|
@@ -348,6 +543,19 @@ class AwsGovcloudIntegrationsApiGatewayArgs:
|
|
|
348
543
|
pulumi.set(self, "tag_value", value)
|
|
349
544
|
|
|
350
545
|
|
|
546
|
+
if not MYPY:
|
|
547
|
+
class AwsGovcloudIntegrationsAutoScalingArgsDict(TypedDict):
|
|
548
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
549
|
+
"""
|
|
550
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
551
|
+
"""
|
|
552
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
553
|
+
"""
|
|
554
|
+
The data polling interval in seconds
|
|
555
|
+
"""
|
|
556
|
+
elif False:
|
|
557
|
+
AwsGovcloudIntegrationsAutoScalingArgsDict: TypeAlias = Mapping[str, Any]
|
|
558
|
+
|
|
351
559
|
@pulumi.input_type
|
|
352
560
|
class AwsGovcloudIntegrationsAutoScalingArgs:
|
|
353
561
|
def __init__(__self__, *,
|
|
@@ -387,6 +595,19 @@ class AwsGovcloudIntegrationsAutoScalingArgs:
|
|
|
387
595
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
388
596
|
|
|
389
597
|
|
|
598
|
+
if not MYPY:
|
|
599
|
+
class AwsGovcloudIntegrationsAwsDirectConnectArgsDict(TypedDict):
|
|
600
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
601
|
+
"""
|
|
602
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
603
|
+
"""
|
|
604
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
605
|
+
"""
|
|
606
|
+
The data polling interval in seconds
|
|
607
|
+
"""
|
|
608
|
+
elif False:
|
|
609
|
+
AwsGovcloudIntegrationsAwsDirectConnectArgsDict: TypeAlias = Mapping[str, Any]
|
|
610
|
+
|
|
390
611
|
@pulumi.input_type
|
|
391
612
|
class AwsGovcloudIntegrationsAwsDirectConnectArgs:
|
|
392
613
|
def __init__(__self__, *,
|
|
@@ -426,6 +647,19 @@ class AwsGovcloudIntegrationsAwsDirectConnectArgs:
|
|
|
426
647
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
427
648
|
|
|
428
649
|
|
|
650
|
+
if not MYPY:
|
|
651
|
+
class AwsGovcloudIntegrationsAwsStatesArgsDict(TypedDict):
|
|
652
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
653
|
+
"""
|
|
654
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
655
|
+
"""
|
|
656
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
657
|
+
"""
|
|
658
|
+
The data polling interval in seconds
|
|
659
|
+
"""
|
|
660
|
+
elif False:
|
|
661
|
+
AwsGovcloudIntegrationsAwsStatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
662
|
+
|
|
429
663
|
@pulumi.input_type
|
|
430
664
|
class AwsGovcloudIntegrationsAwsStatesArgs:
|
|
431
665
|
def __init__(__self__, *,
|
|
@@ -465,6 +699,19 @@ class AwsGovcloudIntegrationsAwsStatesArgs:
|
|
|
465
699
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
466
700
|
|
|
467
701
|
|
|
702
|
+
if not MYPY:
|
|
703
|
+
class AwsGovcloudIntegrationsCloudtrailArgsDict(TypedDict):
|
|
704
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
705
|
+
"""
|
|
706
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
707
|
+
"""
|
|
708
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
709
|
+
"""
|
|
710
|
+
The data polling interval in seconds
|
|
711
|
+
"""
|
|
712
|
+
elif False:
|
|
713
|
+
AwsGovcloudIntegrationsCloudtrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
714
|
+
|
|
468
715
|
@pulumi.input_type
|
|
469
716
|
class AwsGovcloudIntegrationsCloudtrailArgs:
|
|
470
717
|
def __init__(__self__, *,
|
|
@@ -504,6 +751,35 @@ class AwsGovcloudIntegrationsCloudtrailArgs:
|
|
|
504
751
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
505
752
|
|
|
506
753
|
|
|
754
|
+
if not MYPY:
|
|
755
|
+
class AwsGovcloudIntegrationsDynamoDbArgsDict(TypedDict):
|
|
756
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
757
|
+
"""
|
|
758
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
759
|
+
"""
|
|
760
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
761
|
+
"""
|
|
762
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
763
|
+
"""
|
|
764
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
765
|
+
"""
|
|
766
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
767
|
+
"""
|
|
768
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
769
|
+
"""
|
|
770
|
+
The data polling interval in seconds
|
|
771
|
+
"""
|
|
772
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
773
|
+
"""
|
|
774
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
775
|
+
"""
|
|
776
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
777
|
+
"""
|
|
778
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
779
|
+
"""
|
|
780
|
+
elif False:
|
|
781
|
+
AwsGovcloudIntegrationsDynamoDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
782
|
+
|
|
507
783
|
@pulumi.input_type
|
|
508
784
|
class AwsGovcloudIntegrationsDynamoDbArgs:
|
|
509
785
|
def __init__(__self__, *,
|
|
@@ -607,6 +883,31 @@ class AwsGovcloudIntegrationsDynamoDbArgs:
|
|
|
607
883
|
pulumi.set(self, "tag_value", value)
|
|
608
884
|
|
|
609
885
|
|
|
886
|
+
if not MYPY:
|
|
887
|
+
class AwsGovcloudIntegrationsEbsArgsDict(TypedDict):
|
|
888
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
889
|
+
"""
|
|
890
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
891
|
+
"""
|
|
892
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
893
|
+
"""
|
|
894
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
895
|
+
"""
|
|
896
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
897
|
+
"""
|
|
898
|
+
The data polling interval in seconds
|
|
899
|
+
"""
|
|
900
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
901
|
+
"""
|
|
902
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
903
|
+
"""
|
|
904
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
905
|
+
"""
|
|
906
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
907
|
+
"""
|
|
908
|
+
elif False:
|
|
909
|
+
AwsGovcloudIntegrationsEbsArgsDict: TypeAlias = Mapping[str, Any]
|
|
910
|
+
|
|
610
911
|
@pulumi.input_type
|
|
611
912
|
class AwsGovcloudIntegrationsEbsArgs:
|
|
612
913
|
def __init__(__self__, *,
|
|
@@ -694,6 +995,31 @@ class AwsGovcloudIntegrationsEbsArgs:
|
|
|
694
995
|
pulumi.set(self, "tag_value", value)
|
|
695
996
|
|
|
696
997
|
|
|
998
|
+
if not MYPY:
|
|
999
|
+
class AwsGovcloudIntegrationsEc2ArgsDict(TypedDict):
|
|
1000
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1001
|
+
"""
|
|
1002
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1003
|
+
"""
|
|
1004
|
+
fetch_ip_addresses: NotRequired[pulumi.Input[bool]]
|
|
1005
|
+
"""
|
|
1006
|
+
Specify if IP addresses of ec2 instance should be collected
|
|
1007
|
+
"""
|
|
1008
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1009
|
+
"""
|
|
1010
|
+
The data polling interval in seconds
|
|
1011
|
+
"""
|
|
1012
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1013
|
+
"""
|
|
1014
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1015
|
+
"""
|
|
1016
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1017
|
+
"""
|
|
1018
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1019
|
+
"""
|
|
1020
|
+
elif False:
|
|
1021
|
+
AwsGovcloudIntegrationsEc2ArgsDict: TypeAlias = Mapping[str, Any]
|
|
1022
|
+
|
|
697
1023
|
@pulumi.input_type
|
|
698
1024
|
class AwsGovcloudIntegrationsEc2Args:
|
|
699
1025
|
def __init__(__self__, *,
|
|
@@ -781,6 +1107,31 @@ class AwsGovcloudIntegrationsEc2Args:
|
|
|
781
1107
|
pulumi.set(self, "tag_value", value)
|
|
782
1108
|
|
|
783
1109
|
|
|
1110
|
+
if not MYPY:
|
|
1111
|
+
class AwsGovcloudIntegrationsElasticSearchArgsDict(TypedDict):
|
|
1112
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1113
|
+
"""
|
|
1114
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1115
|
+
"""
|
|
1116
|
+
fetch_nodes: NotRequired[pulumi.Input[bool]]
|
|
1117
|
+
"""
|
|
1118
|
+
Specify if IP addresses of ec2 instance should be collected
|
|
1119
|
+
"""
|
|
1120
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1121
|
+
"""
|
|
1122
|
+
The data polling interval in seconds
|
|
1123
|
+
"""
|
|
1124
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1125
|
+
"""
|
|
1126
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1127
|
+
"""
|
|
1128
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1129
|
+
"""
|
|
1130
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1131
|
+
"""
|
|
1132
|
+
elif False:
|
|
1133
|
+
AwsGovcloudIntegrationsElasticSearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
1134
|
+
|
|
784
1135
|
@pulumi.input_type
|
|
785
1136
|
class AwsGovcloudIntegrationsElasticSearchArgs:
|
|
786
1137
|
def __init__(__self__, *,
|
|
@@ -868,6 +1219,27 @@ class AwsGovcloudIntegrationsElasticSearchArgs:
|
|
|
868
1219
|
pulumi.set(self, "tag_value", value)
|
|
869
1220
|
|
|
870
1221
|
|
|
1222
|
+
if not MYPY:
|
|
1223
|
+
class AwsGovcloudIntegrationsElbArgsDict(TypedDict):
|
|
1224
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1225
|
+
"""
|
|
1226
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1227
|
+
"""
|
|
1228
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
1229
|
+
"""
|
|
1230
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1231
|
+
"""
|
|
1232
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
1233
|
+
"""
|
|
1234
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1235
|
+
"""
|
|
1236
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1237
|
+
"""
|
|
1238
|
+
The data polling interval in seconds
|
|
1239
|
+
"""
|
|
1240
|
+
elif False:
|
|
1241
|
+
AwsGovcloudIntegrationsElbArgsDict: TypeAlias = Mapping[str, Any]
|
|
1242
|
+
|
|
871
1243
|
@pulumi.input_type
|
|
872
1244
|
class AwsGovcloudIntegrationsElbArgs:
|
|
873
1245
|
def __init__(__self__, *,
|
|
@@ -939,6 +1311,31 @@ class AwsGovcloudIntegrationsElbArgs:
|
|
|
939
1311
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
940
1312
|
|
|
941
1313
|
|
|
1314
|
+
if not MYPY:
|
|
1315
|
+
class AwsGovcloudIntegrationsEmrArgsDict(TypedDict):
|
|
1316
|
+
aws_regions: NotRequired[pulumi.Input[str]]
|
|
1317
|
+
"""
|
|
1318
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1319
|
+
"""
|
|
1320
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
1321
|
+
"""
|
|
1322
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1323
|
+
"""
|
|
1324
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1325
|
+
"""
|
|
1326
|
+
The data polling interval in seconds
|
|
1327
|
+
"""
|
|
1328
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1329
|
+
"""
|
|
1330
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1331
|
+
"""
|
|
1332
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1333
|
+
"""
|
|
1334
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1335
|
+
"""
|
|
1336
|
+
elif False:
|
|
1337
|
+
AwsGovcloudIntegrationsEmrArgsDict: TypeAlias = Mapping[str, Any]
|
|
1338
|
+
|
|
942
1339
|
@pulumi.input_type
|
|
943
1340
|
class AwsGovcloudIntegrationsEmrArgs:
|
|
944
1341
|
def __init__(__self__, *,
|
|
@@ -1026,6 +1423,23 @@ class AwsGovcloudIntegrationsEmrArgs:
|
|
|
1026
1423
|
pulumi.set(self, "tag_value", value)
|
|
1027
1424
|
|
|
1028
1425
|
|
|
1426
|
+
if not MYPY:
|
|
1427
|
+
class AwsGovcloudIntegrationsIamArgsDict(TypedDict):
|
|
1428
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1429
|
+
"""
|
|
1430
|
+
The data polling interval in seconds
|
|
1431
|
+
"""
|
|
1432
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1433
|
+
"""
|
|
1434
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1435
|
+
"""
|
|
1436
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1437
|
+
"""
|
|
1438
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1439
|
+
"""
|
|
1440
|
+
elif False:
|
|
1441
|
+
AwsGovcloudIntegrationsIamArgsDict: TypeAlias = Mapping[str, Any]
|
|
1442
|
+
|
|
1029
1443
|
@pulumi.input_type
|
|
1030
1444
|
class AwsGovcloudIntegrationsIamArgs:
|
|
1031
1445
|
def __init__(__self__, *,
|
|
@@ -1081,6 +1495,31 @@ class AwsGovcloudIntegrationsIamArgs:
|
|
|
1081
1495
|
pulumi.set(self, "tag_value", value)
|
|
1082
1496
|
|
|
1083
1497
|
|
|
1498
|
+
if not MYPY:
|
|
1499
|
+
class AwsGovcloudIntegrationsLambdaArgsDict(TypedDict):
|
|
1500
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1501
|
+
"""
|
|
1502
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1503
|
+
"""
|
|
1504
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
1505
|
+
"""
|
|
1506
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1507
|
+
"""
|
|
1508
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1509
|
+
"""
|
|
1510
|
+
The data polling interval in seconds
|
|
1511
|
+
"""
|
|
1512
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1513
|
+
"""
|
|
1514
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1515
|
+
"""
|
|
1516
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1517
|
+
"""
|
|
1518
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1519
|
+
"""
|
|
1520
|
+
elif False:
|
|
1521
|
+
AwsGovcloudIntegrationsLambdaArgsDict: TypeAlias = Mapping[str, Any]
|
|
1522
|
+
|
|
1084
1523
|
@pulumi.input_type
|
|
1085
1524
|
class AwsGovcloudIntegrationsLambdaArgs:
|
|
1086
1525
|
def __init__(__self__, *,
|
|
@@ -1168,6 +1607,31 @@ class AwsGovcloudIntegrationsLambdaArgs:
|
|
|
1168
1607
|
pulumi.set(self, "tag_value", value)
|
|
1169
1608
|
|
|
1170
1609
|
|
|
1610
|
+
if not MYPY:
|
|
1611
|
+
class AwsGovcloudIntegrationsRdsArgsDict(TypedDict):
|
|
1612
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1613
|
+
"""
|
|
1614
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1615
|
+
"""
|
|
1616
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
1617
|
+
"""
|
|
1618
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1619
|
+
"""
|
|
1620
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1621
|
+
"""
|
|
1622
|
+
The data polling interval in seconds
|
|
1623
|
+
"""
|
|
1624
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1625
|
+
"""
|
|
1626
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1627
|
+
"""
|
|
1628
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1629
|
+
"""
|
|
1630
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1631
|
+
"""
|
|
1632
|
+
elif False:
|
|
1633
|
+
AwsGovcloudIntegrationsRdsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1634
|
+
|
|
1171
1635
|
@pulumi.input_type
|
|
1172
1636
|
class AwsGovcloudIntegrationsRdsArgs:
|
|
1173
1637
|
def __init__(__self__, *,
|
|
@@ -1255,6 +1719,27 @@ class AwsGovcloudIntegrationsRdsArgs:
|
|
|
1255
1719
|
pulumi.set(self, "tag_value", value)
|
|
1256
1720
|
|
|
1257
1721
|
|
|
1722
|
+
if not MYPY:
|
|
1723
|
+
class AwsGovcloudIntegrationsRedShiftArgsDict(TypedDict):
|
|
1724
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1725
|
+
"""
|
|
1726
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1727
|
+
"""
|
|
1728
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1729
|
+
"""
|
|
1730
|
+
The data polling interval in seconds
|
|
1731
|
+
"""
|
|
1732
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1733
|
+
"""
|
|
1734
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1735
|
+
"""
|
|
1736
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1737
|
+
"""
|
|
1738
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1739
|
+
"""
|
|
1740
|
+
elif False:
|
|
1741
|
+
AwsGovcloudIntegrationsRedShiftArgsDict: TypeAlias = Mapping[str, Any]
|
|
1742
|
+
|
|
1258
1743
|
@pulumi.input_type
|
|
1259
1744
|
class AwsGovcloudIntegrationsRedShiftArgs:
|
|
1260
1745
|
def __init__(__self__, *,
|
|
@@ -1326,6 +1811,19 @@ class AwsGovcloudIntegrationsRedShiftArgs:
|
|
|
1326
1811
|
pulumi.set(self, "tag_value", value)
|
|
1327
1812
|
|
|
1328
1813
|
|
|
1814
|
+
if not MYPY:
|
|
1815
|
+
class AwsGovcloudIntegrationsRoute53ArgsDict(TypedDict):
|
|
1816
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
1817
|
+
"""
|
|
1818
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1819
|
+
"""
|
|
1820
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1821
|
+
"""
|
|
1822
|
+
The data polling interval in seconds
|
|
1823
|
+
"""
|
|
1824
|
+
elif False:
|
|
1825
|
+
AwsGovcloudIntegrationsRoute53ArgsDict: TypeAlias = Mapping[str, Any]
|
|
1826
|
+
|
|
1329
1827
|
@pulumi.input_type
|
|
1330
1828
|
class AwsGovcloudIntegrationsRoute53Args:
|
|
1331
1829
|
def __init__(__self__, *,
|
|
@@ -1365,6 +1863,31 @@ class AwsGovcloudIntegrationsRoute53Args:
|
|
|
1365
1863
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1366
1864
|
|
|
1367
1865
|
|
|
1866
|
+
if not MYPY:
|
|
1867
|
+
class AwsGovcloudIntegrationsS3ArgsDict(TypedDict):
|
|
1868
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
1869
|
+
"""
|
|
1870
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1871
|
+
"""
|
|
1872
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
1873
|
+
"""
|
|
1874
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1875
|
+
"""
|
|
1876
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1877
|
+
"""
|
|
1878
|
+
The data polling interval in seconds
|
|
1879
|
+
"""
|
|
1880
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
1881
|
+
"""
|
|
1882
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1883
|
+
"""
|
|
1884
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
1885
|
+
"""
|
|
1886
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
1887
|
+
"""
|
|
1888
|
+
elif False:
|
|
1889
|
+
AwsGovcloudIntegrationsS3ArgsDict: TypeAlias = Mapping[str, Any]
|
|
1890
|
+
|
|
1368
1891
|
@pulumi.input_type
|
|
1369
1892
|
class AwsGovcloudIntegrationsS3Args:
|
|
1370
1893
|
def __init__(__self__, *,
|
|
@@ -1452,6 +1975,23 @@ class AwsGovcloudIntegrationsS3Args:
|
|
|
1452
1975
|
pulumi.set(self, "tag_value", value)
|
|
1453
1976
|
|
|
1454
1977
|
|
|
1978
|
+
if not MYPY:
|
|
1979
|
+
class AwsGovcloudIntegrationsSnsArgsDict(TypedDict):
|
|
1980
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1981
|
+
"""
|
|
1982
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
1983
|
+
"""
|
|
1984
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
1985
|
+
"""
|
|
1986
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
1987
|
+
"""
|
|
1988
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
1989
|
+
"""
|
|
1990
|
+
The data polling interval in seconds
|
|
1991
|
+
"""
|
|
1992
|
+
elif False:
|
|
1993
|
+
AwsGovcloudIntegrationsSnsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1994
|
+
|
|
1455
1995
|
@pulumi.input_type
|
|
1456
1996
|
class AwsGovcloudIntegrationsSnsArgs:
|
|
1457
1997
|
def __init__(__self__, *,
|
|
@@ -1507,11 +2047,44 @@ class AwsGovcloudIntegrationsSnsArgs:
|
|
|
1507
2047
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1508
2048
|
|
|
1509
2049
|
|
|
1510
|
-
|
|
1511
|
-
class
|
|
1512
|
-
|
|
1513
|
-
|
|
1514
|
-
|
|
2050
|
+
if not MYPY:
|
|
2051
|
+
class AwsGovcloudIntegrationsSqsArgsDict(TypedDict):
|
|
2052
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2053
|
+
"""
|
|
2054
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
2055
|
+
"""
|
|
2056
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
2057
|
+
"""
|
|
2058
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
2059
|
+
"""
|
|
2060
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
2061
|
+
"""
|
|
2062
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
2063
|
+
"""
|
|
2064
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2065
|
+
"""
|
|
2066
|
+
The data polling interval in seconds
|
|
2067
|
+
"""
|
|
2068
|
+
queue_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2069
|
+
"""
|
|
2070
|
+
Specify each name or prefix for the Queues that you want to monitor. Filter values are case-sensitive.
|
|
2071
|
+
"""
|
|
2072
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
2073
|
+
"""
|
|
2074
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2075
|
+
"""
|
|
2076
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
2077
|
+
"""
|
|
2078
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2079
|
+
"""
|
|
2080
|
+
elif False:
|
|
2081
|
+
AwsGovcloudIntegrationsSqsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2082
|
+
|
|
2083
|
+
@pulumi.input_type
|
|
2084
|
+
class AwsGovcloudIntegrationsSqsArgs:
|
|
2085
|
+
def __init__(__self__, *,
|
|
2086
|
+
aws_regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2087
|
+
fetch_extended_inventory: Optional[pulumi.Input[bool]] = None,
|
|
1515
2088
|
fetch_tags: Optional[pulumi.Input[bool]] = None,
|
|
1516
2089
|
metrics_polling_interval: Optional[pulumi.Input[int]] = None,
|
|
1517
2090
|
queue_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
@@ -1626,6 +2199,39 @@ class AwsGovcloudIntegrationsSqsArgs:
|
|
|
1626
2199
|
pulumi.set(self, "tag_value", value)
|
|
1627
2200
|
|
|
1628
2201
|
|
|
2202
|
+
if not MYPY:
|
|
2203
|
+
class AwsIntegrationsAlbArgsDict(TypedDict):
|
|
2204
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2205
|
+
"""
|
|
2206
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2207
|
+
"""
|
|
2208
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
2209
|
+
"""
|
|
2210
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
2211
|
+
"""
|
|
2212
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
2213
|
+
"""
|
|
2214
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
2215
|
+
"""
|
|
2216
|
+
load_balancer_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2217
|
+
"""
|
|
2218
|
+
Specify each name or prefix for the LBs that you want to monitor. Filter values are case-sensitive.
|
|
2219
|
+
"""
|
|
2220
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2221
|
+
"""
|
|
2222
|
+
The data polling interval in seconds.
|
|
2223
|
+
"""
|
|
2224
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
2225
|
+
"""
|
|
2226
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2227
|
+
"""
|
|
2228
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
2229
|
+
"""
|
|
2230
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2231
|
+
"""
|
|
2232
|
+
elif False:
|
|
2233
|
+
AwsIntegrationsAlbArgsDict: TypeAlias = Mapping[str, Any]
|
|
2234
|
+
|
|
1629
2235
|
@pulumi.input_type
|
|
1630
2236
|
class AwsIntegrationsAlbArgs:
|
|
1631
2237
|
def __init__(__self__, *,
|
|
@@ -1745,6 +2351,31 @@ class AwsIntegrationsAlbArgs:
|
|
|
1745
2351
|
pulumi.set(self, "tag_value", value)
|
|
1746
2352
|
|
|
1747
2353
|
|
|
2354
|
+
if not MYPY:
|
|
2355
|
+
class AwsIntegrationsApiGatewayArgsDict(TypedDict):
|
|
2356
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2357
|
+
"""
|
|
2358
|
+
Specify each AWS region that includes the resources that you want to monitor
|
|
2359
|
+
"""
|
|
2360
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2361
|
+
"""
|
|
2362
|
+
The data polling interval in seconds.
|
|
2363
|
+
"""
|
|
2364
|
+
stage_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2365
|
+
"""
|
|
2366
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
2367
|
+
"""
|
|
2368
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
2369
|
+
"""
|
|
2370
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2371
|
+
"""
|
|
2372
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
2373
|
+
"""
|
|
2374
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
2375
|
+
"""
|
|
2376
|
+
elif False:
|
|
2377
|
+
AwsIntegrationsApiGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
2378
|
+
|
|
1748
2379
|
@pulumi.input_type
|
|
1749
2380
|
class AwsIntegrationsApiGatewayArgs:
|
|
1750
2381
|
def __init__(__self__, *,
|
|
@@ -1832,6 +2463,19 @@ class AwsIntegrationsApiGatewayArgs:
|
|
|
1832
2463
|
pulumi.set(self, "tag_value", value)
|
|
1833
2464
|
|
|
1834
2465
|
|
|
2466
|
+
if not MYPY:
|
|
2467
|
+
class AwsIntegrationsAutoScalingArgsDict(TypedDict):
|
|
2468
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2469
|
+
"""
|
|
2470
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2471
|
+
"""
|
|
2472
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2473
|
+
"""
|
|
2474
|
+
The data polling interval in seconds.
|
|
2475
|
+
"""
|
|
2476
|
+
elif False:
|
|
2477
|
+
AwsIntegrationsAutoScalingArgsDict: TypeAlias = Mapping[str, Any]
|
|
2478
|
+
|
|
1835
2479
|
@pulumi.input_type
|
|
1836
2480
|
class AwsIntegrationsAutoScalingArgs:
|
|
1837
2481
|
def __init__(__self__, *,
|
|
@@ -1871,6 +2515,19 @@ class AwsIntegrationsAutoScalingArgs:
|
|
|
1871
2515
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1872
2516
|
|
|
1873
2517
|
|
|
2518
|
+
if not MYPY:
|
|
2519
|
+
class AwsIntegrationsAwsAppSyncArgsDict(TypedDict):
|
|
2520
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2521
|
+
"""
|
|
2522
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2523
|
+
"""
|
|
2524
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2525
|
+
"""
|
|
2526
|
+
The data polling interval in seconds.
|
|
2527
|
+
"""
|
|
2528
|
+
elif False:
|
|
2529
|
+
AwsIntegrationsAwsAppSyncArgsDict: TypeAlias = Mapping[str, Any]
|
|
2530
|
+
|
|
1874
2531
|
@pulumi.input_type
|
|
1875
2532
|
class AwsIntegrationsAwsAppSyncArgs:
|
|
1876
2533
|
def __init__(__self__, *,
|
|
@@ -1910,6 +2567,19 @@ class AwsIntegrationsAwsAppSyncArgs:
|
|
|
1910
2567
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1911
2568
|
|
|
1912
2569
|
|
|
2570
|
+
if not MYPY:
|
|
2571
|
+
class AwsIntegrationsAwsAthenaArgsDict(TypedDict):
|
|
2572
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2573
|
+
"""
|
|
2574
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2575
|
+
"""
|
|
2576
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2577
|
+
"""
|
|
2578
|
+
The data polling interval in seconds.
|
|
2579
|
+
"""
|
|
2580
|
+
elif False:
|
|
2581
|
+
AwsIntegrationsAwsAthenaArgsDict: TypeAlias = Mapping[str, Any]
|
|
2582
|
+
|
|
1913
2583
|
@pulumi.input_type
|
|
1914
2584
|
class AwsIntegrationsAwsAthenaArgs:
|
|
1915
2585
|
def __init__(__self__, *,
|
|
@@ -1949,6 +2619,19 @@ class AwsIntegrationsAwsAthenaArgs:
|
|
|
1949
2619
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1950
2620
|
|
|
1951
2621
|
|
|
2622
|
+
if not MYPY:
|
|
2623
|
+
class AwsIntegrationsAwsCognitoArgsDict(TypedDict):
|
|
2624
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2625
|
+
"""
|
|
2626
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2627
|
+
"""
|
|
2628
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2629
|
+
"""
|
|
2630
|
+
The data polling interval in seconds.
|
|
2631
|
+
"""
|
|
2632
|
+
elif False:
|
|
2633
|
+
AwsIntegrationsAwsCognitoArgsDict: TypeAlias = Mapping[str, Any]
|
|
2634
|
+
|
|
1952
2635
|
@pulumi.input_type
|
|
1953
2636
|
class AwsIntegrationsAwsCognitoArgs:
|
|
1954
2637
|
def __init__(__self__, *,
|
|
@@ -1988,6 +2671,19 @@ class AwsIntegrationsAwsCognitoArgs:
|
|
|
1988
2671
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
1989
2672
|
|
|
1990
2673
|
|
|
2674
|
+
if not MYPY:
|
|
2675
|
+
class AwsIntegrationsAwsConnectArgsDict(TypedDict):
|
|
2676
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2677
|
+
"""
|
|
2678
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2679
|
+
"""
|
|
2680
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2681
|
+
"""
|
|
2682
|
+
The data polling interval in seconds.
|
|
2683
|
+
"""
|
|
2684
|
+
elif False:
|
|
2685
|
+
AwsIntegrationsAwsConnectArgsDict: TypeAlias = Mapping[str, Any]
|
|
2686
|
+
|
|
1991
2687
|
@pulumi.input_type
|
|
1992
2688
|
class AwsIntegrationsAwsConnectArgs:
|
|
1993
2689
|
def __init__(__self__, *,
|
|
@@ -2027,6 +2723,19 @@ class AwsIntegrationsAwsConnectArgs:
|
|
|
2027
2723
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2028
2724
|
|
|
2029
2725
|
|
|
2726
|
+
if not MYPY:
|
|
2727
|
+
class AwsIntegrationsAwsDirectConnectArgsDict(TypedDict):
|
|
2728
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2729
|
+
"""
|
|
2730
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2731
|
+
"""
|
|
2732
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2733
|
+
"""
|
|
2734
|
+
The data polling interval in seconds.
|
|
2735
|
+
"""
|
|
2736
|
+
elif False:
|
|
2737
|
+
AwsIntegrationsAwsDirectConnectArgsDict: TypeAlias = Mapping[str, Any]
|
|
2738
|
+
|
|
2030
2739
|
@pulumi.input_type
|
|
2031
2740
|
class AwsIntegrationsAwsDirectConnectArgs:
|
|
2032
2741
|
def __init__(__self__, *,
|
|
@@ -2066,6 +2775,19 @@ class AwsIntegrationsAwsDirectConnectArgs:
|
|
|
2066
2775
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2067
2776
|
|
|
2068
2777
|
|
|
2778
|
+
if not MYPY:
|
|
2779
|
+
class AwsIntegrationsAwsFsxArgsDict(TypedDict):
|
|
2780
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2781
|
+
"""
|
|
2782
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2783
|
+
"""
|
|
2784
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2785
|
+
"""
|
|
2786
|
+
The data polling interval in seconds.
|
|
2787
|
+
"""
|
|
2788
|
+
elif False:
|
|
2789
|
+
AwsIntegrationsAwsFsxArgsDict: TypeAlias = Mapping[str, Any]
|
|
2790
|
+
|
|
2069
2791
|
@pulumi.input_type
|
|
2070
2792
|
class AwsIntegrationsAwsFsxArgs:
|
|
2071
2793
|
def __init__(__self__, *,
|
|
@@ -2105,6 +2827,19 @@ class AwsIntegrationsAwsFsxArgs:
|
|
|
2105
2827
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2106
2828
|
|
|
2107
2829
|
|
|
2830
|
+
if not MYPY:
|
|
2831
|
+
class AwsIntegrationsAwsGlueArgsDict(TypedDict):
|
|
2832
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2833
|
+
"""
|
|
2834
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2835
|
+
"""
|
|
2836
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2837
|
+
"""
|
|
2838
|
+
The data polling interval in seconds.
|
|
2839
|
+
"""
|
|
2840
|
+
elif False:
|
|
2841
|
+
AwsIntegrationsAwsGlueArgsDict: TypeAlias = Mapping[str, Any]
|
|
2842
|
+
|
|
2108
2843
|
@pulumi.input_type
|
|
2109
2844
|
class AwsIntegrationsAwsGlueArgs:
|
|
2110
2845
|
def __init__(__self__, *,
|
|
@@ -2144,6 +2879,19 @@ class AwsIntegrationsAwsGlueArgs:
|
|
|
2144
2879
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2145
2880
|
|
|
2146
2881
|
|
|
2882
|
+
if not MYPY:
|
|
2883
|
+
class AwsIntegrationsAwsKinesisAnalyticsArgsDict(TypedDict):
|
|
2884
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2885
|
+
"""
|
|
2886
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2887
|
+
"""
|
|
2888
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2889
|
+
"""
|
|
2890
|
+
The data polling interval in seconds.
|
|
2891
|
+
"""
|
|
2892
|
+
elif False:
|
|
2893
|
+
AwsIntegrationsAwsKinesisAnalyticsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2894
|
+
|
|
2147
2895
|
@pulumi.input_type
|
|
2148
2896
|
class AwsIntegrationsAwsKinesisAnalyticsArgs:
|
|
2149
2897
|
def __init__(__self__, *,
|
|
@@ -2183,6 +2931,19 @@ class AwsIntegrationsAwsKinesisAnalyticsArgs:
|
|
|
2183
2931
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2184
2932
|
|
|
2185
2933
|
|
|
2934
|
+
if not MYPY:
|
|
2935
|
+
class AwsIntegrationsAwsMediaConvertArgsDict(TypedDict):
|
|
2936
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2937
|
+
"""
|
|
2938
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2939
|
+
"""
|
|
2940
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2941
|
+
"""
|
|
2942
|
+
The data polling interval in seconds.
|
|
2943
|
+
"""
|
|
2944
|
+
elif False:
|
|
2945
|
+
AwsIntegrationsAwsMediaConvertArgsDict: TypeAlias = Mapping[str, Any]
|
|
2946
|
+
|
|
2186
2947
|
@pulumi.input_type
|
|
2187
2948
|
class AwsIntegrationsAwsMediaConvertArgs:
|
|
2188
2949
|
def __init__(__self__, *,
|
|
@@ -2222,6 +2983,19 @@ class AwsIntegrationsAwsMediaConvertArgs:
|
|
|
2222
2983
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2223
2984
|
|
|
2224
2985
|
|
|
2986
|
+
if not MYPY:
|
|
2987
|
+
class AwsIntegrationsAwsMediaPackageVodArgsDict(TypedDict):
|
|
2988
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2989
|
+
"""
|
|
2990
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
2991
|
+
"""
|
|
2992
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
2993
|
+
"""
|
|
2994
|
+
The data polling interval in seconds.
|
|
2995
|
+
"""
|
|
2996
|
+
elif False:
|
|
2997
|
+
AwsIntegrationsAwsMediaPackageVodArgsDict: TypeAlias = Mapping[str, Any]
|
|
2998
|
+
|
|
2225
2999
|
@pulumi.input_type
|
|
2226
3000
|
class AwsIntegrationsAwsMediaPackageVodArgs:
|
|
2227
3001
|
def __init__(__self__, *,
|
|
@@ -2261,6 +3035,19 @@ class AwsIntegrationsAwsMediaPackageVodArgs:
|
|
|
2261
3035
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2262
3036
|
|
|
2263
3037
|
|
|
3038
|
+
if not MYPY:
|
|
3039
|
+
class AwsIntegrationsAwsMqArgsDict(TypedDict):
|
|
3040
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3041
|
+
"""
|
|
3042
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3043
|
+
"""
|
|
3044
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3045
|
+
"""
|
|
3046
|
+
The data polling interval in seconds.
|
|
3047
|
+
"""
|
|
3048
|
+
elif False:
|
|
3049
|
+
AwsIntegrationsAwsMqArgsDict: TypeAlias = Mapping[str, Any]
|
|
3050
|
+
|
|
2264
3051
|
@pulumi.input_type
|
|
2265
3052
|
class AwsIntegrationsAwsMqArgs:
|
|
2266
3053
|
def __init__(__self__, *,
|
|
@@ -2300,6 +3087,19 @@ class AwsIntegrationsAwsMqArgs:
|
|
|
2300
3087
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2301
3088
|
|
|
2302
3089
|
|
|
3090
|
+
if not MYPY:
|
|
3091
|
+
class AwsIntegrationsAwsMskArgsDict(TypedDict):
|
|
3092
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3093
|
+
"""
|
|
3094
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3095
|
+
"""
|
|
3096
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3097
|
+
"""
|
|
3098
|
+
The data polling interval in seconds.
|
|
3099
|
+
"""
|
|
3100
|
+
elif False:
|
|
3101
|
+
AwsIntegrationsAwsMskArgsDict: TypeAlias = Mapping[str, Any]
|
|
3102
|
+
|
|
2303
3103
|
@pulumi.input_type
|
|
2304
3104
|
class AwsIntegrationsAwsMskArgs:
|
|
2305
3105
|
def __init__(__self__, *,
|
|
@@ -2339,6 +3139,19 @@ class AwsIntegrationsAwsMskArgs:
|
|
|
2339
3139
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2340
3140
|
|
|
2341
3141
|
|
|
3142
|
+
if not MYPY:
|
|
3143
|
+
class AwsIntegrationsAwsNeptuneArgsDict(TypedDict):
|
|
3144
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3145
|
+
"""
|
|
3146
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3147
|
+
"""
|
|
3148
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3149
|
+
"""
|
|
3150
|
+
The data polling interval in seconds.
|
|
3151
|
+
"""
|
|
3152
|
+
elif False:
|
|
3153
|
+
AwsIntegrationsAwsNeptuneArgsDict: TypeAlias = Mapping[str, Any]
|
|
3154
|
+
|
|
2342
3155
|
@pulumi.input_type
|
|
2343
3156
|
class AwsIntegrationsAwsNeptuneArgs:
|
|
2344
3157
|
def __init__(__self__, *,
|
|
@@ -2378,6 +3191,19 @@ class AwsIntegrationsAwsNeptuneArgs:
|
|
|
2378
3191
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2379
3192
|
|
|
2380
3193
|
|
|
3194
|
+
if not MYPY:
|
|
3195
|
+
class AwsIntegrationsAwsQldbArgsDict(TypedDict):
|
|
3196
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3197
|
+
"""
|
|
3198
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3199
|
+
"""
|
|
3200
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3201
|
+
"""
|
|
3202
|
+
The data polling interval in seconds.
|
|
3203
|
+
"""
|
|
3204
|
+
elif False:
|
|
3205
|
+
AwsIntegrationsAwsQldbArgsDict: TypeAlias = Mapping[str, Any]
|
|
3206
|
+
|
|
2381
3207
|
@pulumi.input_type
|
|
2382
3208
|
class AwsIntegrationsAwsQldbArgs:
|
|
2383
3209
|
def __init__(__self__, *,
|
|
@@ -2417,6 +3243,19 @@ class AwsIntegrationsAwsQldbArgs:
|
|
|
2417
3243
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2418
3244
|
|
|
2419
3245
|
|
|
3246
|
+
if not MYPY:
|
|
3247
|
+
class AwsIntegrationsAwsRoute53resolverArgsDict(TypedDict):
|
|
3248
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3249
|
+
"""
|
|
3250
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3251
|
+
"""
|
|
3252
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3253
|
+
"""
|
|
3254
|
+
The data polling interval in seconds.
|
|
3255
|
+
"""
|
|
3256
|
+
elif False:
|
|
3257
|
+
AwsIntegrationsAwsRoute53resolverArgsDict: TypeAlias = Mapping[str, Any]
|
|
3258
|
+
|
|
2420
3259
|
@pulumi.input_type
|
|
2421
3260
|
class AwsIntegrationsAwsRoute53resolverArgs:
|
|
2422
3261
|
def __init__(__self__, *,
|
|
@@ -2456,6 +3295,19 @@ class AwsIntegrationsAwsRoute53resolverArgs:
|
|
|
2456
3295
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2457
3296
|
|
|
2458
3297
|
|
|
3298
|
+
if not MYPY:
|
|
3299
|
+
class AwsIntegrationsAwsStatesArgsDict(TypedDict):
|
|
3300
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3301
|
+
"""
|
|
3302
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3303
|
+
"""
|
|
3304
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3305
|
+
"""
|
|
3306
|
+
The data polling interval in seconds.
|
|
3307
|
+
"""
|
|
3308
|
+
elif False:
|
|
3309
|
+
AwsIntegrationsAwsStatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
3310
|
+
|
|
2459
3311
|
@pulumi.input_type
|
|
2460
3312
|
class AwsIntegrationsAwsStatesArgs:
|
|
2461
3313
|
def __init__(__self__, *,
|
|
@@ -2495,6 +3347,19 @@ class AwsIntegrationsAwsStatesArgs:
|
|
|
2495
3347
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2496
3348
|
|
|
2497
3349
|
|
|
3350
|
+
if not MYPY:
|
|
3351
|
+
class AwsIntegrationsAwsTransitGatewayArgsDict(TypedDict):
|
|
3352
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3353
|
+
"""
|
|
3354
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3355
|
+
"""
|
|
3356
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3357
|
+
"""
|
|
3358
|
+
The data polling interval in seconds.
|
|
3359
|
+
"""
|
|
3360
|
+
elif False:
|
|
3361
|
+
AwsIntegrationsAwsTransitGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
3362
|
+
|
|
2498
3363
|
@pulumi.input_type
|
|
2499
3364
|
class AwsIntegrationsAwsTransitGatewayArgs:
|
|
2500
3365
|
def __init__(__self__, *,
|
|
@@ -2534,6 +3399,19 @@ class AwsIntegrationsAwsTransitGatewayArgs:
|
|
|
2534
3399
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2535
3400
|
|
|
2536
3401
|
|
|
3402
|
+
if not MYPY:
|
|
3403
|
+
class AwsIntegrationsAwsWafArgsDict(TypedDict):
|
|
3404
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3405
|
+
"""
|
|
3406
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3407
|
+
"""
|
|
3408
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3409
|
+
"""
|
|
3410
|
+
The data polling interval in seconds.
|
|
3411
|
+
"""
|
|
3412
|
+
elif False:
|
|
3413
|
+
AwsIntegrationsAwsWafArgsDict: TypeAlias = Mapping[str, Any]
|
|
3414
|
+
|
|
2537
3415
|
@pulumi.input_type
|
|
2538
3416
|
class AwsIntegrationsAwsWafArgs:
|
|
2539
3417
|
def __init__(__self__, *,
|
|
@@ -2573,6 +3451,19 @@ class AwsIntegrationsAwsWafArgs:
|
|
|
2573
3451
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2574
3452
|
|
|
2575
3453
|
|
|
3454
|
+
if not MYPY:
|
|
3455
|
+
class AwsIntegrationsAwsWafv2ArgsDict(TypedDict):
|
|
3456
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3457
|
+
"""
|
|
3458
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3459
|
+
"""
|
|
3460
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3461
|
+
"""
|
|
3462
|
+
The data polling interval in seconds.
|
|
3463
|
+
"""
|
|
3464
|
+
elif False:
|
|
3465
|
+
AwsIntegrationsAwsWafv2ArgsDict: TypeAlias = Mapping[str, Any]
|
|
3466
|
+
|
|
2576
3467
|
@pulumi.input_type
|
|
2577
3468
|
class AwsIntegrationsAwsWafv2Args:
|
|
2578
3469
|
def __init__(__self__, *,
|
|
@@ -2612,6 +3503,15 @@ class AwsIntegrationsAwsWafv2Args:
|
|
|
2612
3503
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2613
3504
|
|
|
2614
3505
|
|
|
3506
|
+
if not MYPY:
|
|
3507
|
+
class AwsIntegrationsBillingArgsDict(TypedDict):
|
|
3508
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3509
|
+
"""
|
|
3510
|
+
The data polling interval in seconds.
|
|
3511
|
+
"""
|
|
3512
|
+
elif False:
|
|
3513
|
+
AwsIntegrationsBillingArgsDict: TypeAlias = Mapping[str, Any]
|
|
3514
|
+
|
|
2615
3515
|
@pulumi.input_type
|
|
2616
3516
|
class AwsIntegrationsBillingArgs:
|
|
2617
3517
|
def __init__(__self__, *,
|
|
@@ -2635,6 +3535,31 @@ class AwsIntegrationsBillingArgs:
|
|
|
2635
3535
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2636
3536
|
|
|
2637
3537
|
|
|
3538
|
+
if not MYPY:
|
|
3539
|
+
class AwsIntegrationsCloudfrontArgsDict(TypedDict):
|
|
3540
|
+
fetch_lambdas_at_edge: NotRequired[pulumi.Input[bool]]
|
|
3541
|
+
"""
|
|
3542
|
+
Specify if Lambdas@Edge should be monitored. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
3543
|
+
"""
|
|
3544
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
3545
|
+
"""
|
|
3546
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
3547
|
+
"""
|
|
3548
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3549
|
+
"""
|
|
3550
|
+
The data polling interval in seconds.
|
|
3551
|
+
"""
|
|
3552
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
3553
|
+
"""
|
|
3554
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3555
|
+
"""
|
|
3556
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
3557
|
+
"""
|
|
3558
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3559
|
+
"""
|
|
3560
|
+
elif False:
|
|
3561
|
+
AwsIntegrationsCloudfrontArgsDict: TypeAlias = Mapping[str, Any]
|
|
3562
|
+
|
|
2638
3563
|
@pulumi.input_type
|
|
2639
3564
|
class AwsIntegrationsCloudfrontArgs:
|
|
2640
3565
|
def __init__(__self__, *,
|
|
@@ -2722,6 +3647,19 @@ class AwsIntegrationsCloudfrontArgs:
|
|
|
2722
3647
|
pulumi.set(self, "tag_value", value)
|
|
2723
3648
|
|
|
2724
3649
|
|
|
3650
|
+
if not MYPY:
|
|
3651
|
+
class AwsIntegrationsCloudtrailArgsDict(TypedDict):
|
|
3652
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3653
|
+
"""
|
|
3654
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3655
|
+
"""
|
|
3656
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3657
|
+
"""
|
|
3658
|
+
The data polling interval in seconds.
|
|
3659
|
+
"""
|
|
3660
|
+
elif False:
|
|
3661
|
+
AwsIntegrationsCloudtrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
3662
|
+
|
|
2725
3663
|
@pulumi.input_type
|
|
2726
3664
|
class AwsIntegrationsCloudtrailArgs:
|
|
2727
3665
|
def __init__(__self__, *,
|
|
@@ -2761,6 +3699,19 @@ class AwsIntegrationsCloudtrailArgs:
|
|
|
2761
3699
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2762
3700
|
|
|
2763
3701
|
|
|
3702
|
+
if not MYPY:
|
|
3703
|
+
class AwsIntegrationsDocDbArgsDict(TypedDict):
|
|
3704
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3705
|
+
"""
|
|
3706
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3707
|
+
"""
|
|
3708
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3709
|
+
"""
|
|
3710
|
+
The data polling interval in seconds.
|
|
3711
|
+
"""
|
|
3712
|
+
elif False:
|
|
3713
|
+
AwsIntegrationsDocDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
3714
|
+
|
|
2764
3715
|
@pulumi.input_type
|
|
2765
3716
|
class AwsIntegrationsDocDbArgs:
|
|
2766
3717
|
def __init__(__self__, *,
|
|
@@ -2800,6 +3751,35 @@ class AwsIntegrationsDocDbArgs:
|
|
|
2800
3751
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
2801
3752
|
|
|
2802
3753
|
|
|
3754
|
+
if not MYPY:
|
|
3755
|
+
class AwsIntegrationsDynamodbArgsDict(TypedDict):
|
|
3756
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3757
|
+
"""
|
|
3758
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3759
|
+
"""
|
|
3760
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
3761
|
+
"""
|
|
3762
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
3763
|
+
"""
|
|
3764
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
3765
|
+
"""
|
|
3766
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
3767
|
+
"""
|
|
3768
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3769
|
+
"""
|
|
3770
|
+
The data polling interval in seconds.
|
|
3771
|
+
"""
|
|
3772
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
3773
|
+
"""
|
|
3774
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3775
|
+
"""
|
|
3776
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
3777
|
+
"""
|
|
3778
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3779
|
+
"""
|
|
3780
|
+
elif False:
|
|
3781
|
+
AwsIntegrationsDynamodbArgsDict: TypeAlias = Mapping[str, Any]
|
|
3782
|
+
|
|
2803
3783
|
@pulumi.input_type
|
|
2804
3784
|
class AwsIntegrationsDynamodbArgs:
|
|
2805
3785
|
def __init__(__self__, *,
|
|
@@ -2903,6 +3883,31 @@ class AwsIntegrationsDynamodbArgs:
|
|
|
2903
3883
|
pulumi.set(self, "tag_value", value)
|
|
2904
3884
|
|
|
2905
3885
|
|
|
3886
|
+
if not MYPY:
|
|
3887
|
+
class AwsIntegrationsEbsArgsDict(TypedDict):
|
|
3888
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3889
|
+
"""
|
|
3890
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
3891
|
+
"""
|
|
3892
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
3893
|
+
"""
|
|
3894
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
3895
|
+
"""
|
|
3896
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
3897
|
+
"""
|
|
3898
|
+
The data polling interval in seconds.
|
|
3899
|
+
"""
|
|
3900
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
3901
|
+
"""
|
|
3902
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3903
|
+
"""
|
|
3904
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
3905
|
+
"""
|
|
3906
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
3907
|
+
"""
|
|
3908
|
+
elif False:
|
|
3909
|
+
AwsIntegrationsEbsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3910
|
+
|
|
2906
3911
|
@pulumi.input_type
|
|
2907
3912
|
class AwsIntegrationsEbsArgs:
|
|
2908
3913
|
def __init__(__self__, *,
|
|
@@ -2990,6 +3995,35 @@ class AwsIntegrationsEbsArgs:
|
|
|
2990
3995
|
pulumi.set(self, "tag_value", value)
|
|
2991
3996
|
|
|
2992
3997
|
|
|
3998
|
+
if not MYPY:
|
|
3999
|
+
class AwsIntegrationsEc2ArgsDict(TypedDict):
|
|
4000
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4001
|
+
"""
|
|
4002
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4003
|
+
"""
|
|
4004
|
+
duplicate_ec2_tags: NotRequired[pulumi.Input[bool]]
|
|
4005
|
+
"""
|
|
4006
|
+
Specify if the old legacy metadata and tag names have to be kept, it will consume more ingest data size
|
|
4007
|
+
"""
|
|
4008
|
+
fetch_ip_addresses: NotRequired[pulumi.Input[bool]]
|
|
4009
|
+
"""
|
|
4010
|
+
Specify if IP addresses of ec2 instance should be collected
|
|
4011
|
+
"""
|
|
4012
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4013
|
+
"""
|
|
4014
|
+
The data polling interval in seconds.
|
|
4015
|
+
"""
|
|
4016
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4017
|
+
"""
|
|
4018
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4019
|
+
"""
|
|
4020
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4021
|
+
"""
|
|
4022
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4023
|
+
"""
|
|
4024
|
+
elif False:
|
|
4025
|
+
AwsIntegrationsEc2ArgsDict: TypeAlias = Mapping[str, Any]
|
|
4026
|
+
|
|
2993
4027
|
@pulumi.input_type
|
|
2994
4028
|
class AwsIntegrationsEc2Args:
|
|
2995
4029
|
def __init__(__self__, *,
|
|
@@ -3093,6 +4127,31 @@ class AwsIntegrationsEc2Args:
|
|
|
3093
4127
|
pulumi.set(self, "tag_value", value)
|
|
3094
4128
|
|
|
3095
4129
|
|
|
4130
|
+
if not MYPY:
|
|
4131
|
+
class AwsIntegrationsEcsArgsDict(TypedDict):
|
|
4132
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4133
|
+
"""
|
|
4134
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4135
|
+
"""
|
|
4136
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4137
|
+
"""
|
|
4138
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4139
|
+
"""
|
|
4140
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4141
|
+
"""
|
|
4142
|
+
The data polling interval in seconds.
|
|
4143
|
+
"""
|
|
4144
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4145
|
+
"""
|
|
4146
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4147
|
+
"""
|
|
4148
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4149
|
+
"""
|
|
4150
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4151
|
+
"""
|
|
4152
|
+
elif False:
|
|
4153
|
+
AwsIntegrationsEcsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4154
|
+
|
|
3096
4155
|
@pulumi.input_type
|
|
3097
4156
|
class AwsIntegrationsEcsArgs:
|
|
3098
4157
|
def __init__(__self__, *,
|
|
@@ -3180,6 +4239,31 @@ class AwsIntegrationsEcsArgs:
|
|
|
3180
4239
|
pulumi.set(self, "tag_value", value)
|
|
3181
4240
|
|
|
3182
4241
|
|
|
4242
|
+
if not MYPY:
|
|
4243
|
+
class AwsIntegrationsEfsArgsDict(TypedDict):
|
|
4244
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4245
|
+
"""
|
|
4246
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4247
|
+
"""
|
|
4248
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4249
|
+
"""
|
|
4250
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4251
|
+
"""
|
|
4252
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4253
|
+
"""
|
|
4254
|
+
The data polling interval in seconds.
|
|
4255
|
+
"""
|
|
4256
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4257
|
+
"""
|
|
4258
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4259
|
+
"""
|
|
4260
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4261
|
+
"""
|
|
4262
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4263
|
+
"""
|
|
4264
|
+
elif False:
|
|
4265
|
+
AwsIntegrationsEfsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4266
|
+
|
|
3183
4267
|
@pulumi.input_type
|
|
3184
4268
|
class AwsIntegrationsEfsArgs:
|
|
3185
4269
|
def __init__(__self__, *,
|
|
@@ -3267,6 +4351,31 @@ class AwsIntegrationsEfsArgs:
|
|
|
3267
4351
|
pulumi.set(self, "tag_value", value)
|
|
3268
4352
|
|
|
3269
4353
|
|
|
4354
|
+
if not MYPY:
|
|
4355
|
+
class AwsIntegrationsElasticacheArgsDict(TypedDict):
|
|
4356
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4357
|
+
"""
|
|
4358
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4359
|
+
"""
|
|
4360
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4361
|
+
"""
|
|
4362
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4363
|
+
"""
|
|
4364
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4365
|
+
"""
|
|
4366
|
+
The data polling interval in seconds.
|
|
4367
|
+
"""
|
|
4368
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4369
|
+
"""
|
|
4370
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4371
|
+
"""
|
|
4372
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4373
|
+
"""
|
|
4374
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4375
|
+
"""
|
|
4376
|
+
elif False:
|
|
4377
|
+
AwsIntegrationsElasticacheArgsDict: TypeAlias = Mapping[str, Any]
|
|
4378
|
+
|
|
3270
4379
|
@pulumi.input_type
|
|
3271
4380
|
class AwsIntegrationsElasticacheArgs:
|
|
3272
4381
|
def __init__(__self__, *,
|
|
@@ -3354,6 +4463,35 @@ class AwsIntegrationsElasticacheArgs:
|
|
|
3354
4463
|
pulumi.set(self, "tag_value", value)
|
|
3355
4464
|
|
|
3356
4465
|
|
|
4466
|
+
if not MYPY:
|
|
4467
|
+
class AwsIntegrationsElasticbeanstalkArgsDict(TypedDict):
|
|
4468
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4469
|
+
"""
|
|
4470
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4471
|
+
"""
|
|
4472
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
4473
|
+
"""
|
|
4474
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4475
|
+
"""
|
|
4476
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4477
|
+
"""
|
|
4478
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4479
|
+
"""
|
|
4480
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4481
|
+
"""
|
|
4482
|
+
The data polling interval in seconds.
|
|
4483
|
+
"""
|
|
4484
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4485
|
+
"""
|
|
4486
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4487
|
+
"""
|
|
4488
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4489
|
+
"""
|
|
4490
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4491
|
+
"""
|
|
4492
|
+
elif False:
|
|
4493
|
+
AwsIntegrationsElasticbeanstalkArgsDict: TypeAlias = Mapping[str, Any]
|
|
4494
|
+
|
|
3357
4495
|
@pulumi.input_type
|
|
3358
4496
|
class AwsIntegrationsElasticbeanstalkArgs:
|
|
3359
4497
|
def __init__(__self__, *,
|
|
@@ -3457,6 +4595,31 @@ class AwsIntegrationsElasticbeanstalkArgs:
|
|
|
3457
4595
|
pulumi.set(self, "tag_value", value)
|
|
3458
4596
|
|
|
3459
4597
|
|
|
4598
|
+
if not MYPY:
|
|
4599
|
+
class AwsIntegrationsElasticsearchArgsDict(TypedDict):
|
|
4600
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4601
|
+
"""
|
|
4602
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4603
|
+
"""
|
|
4604
|
+
fetch_nodes: NotRequired[pulumi.Input[bool]]
|
|
4605
|
+
"""
|
|
4606
|
+
Specify if metrics should be collected for nodes. Turning it on will increase the number of API calls made to CloudWatch.
|
|
4607
|
+
"""
|
|
4608
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4609
|
+
"""
|
|
4610
|
+
The data polling interval in seconds.
|
|
4611
|
+
"""
|
|
4612
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4613
|
+
"""
|
|
4614
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4615
|
+
"""
|
|
4616
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4617
|
+
"""
|
|
4618
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4619
|
+
"""
|
|
4620
|
+
elif False:
|
|
4621
|
+
AwsIntegrationsElasticsearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
4622
|
+
|
|
3460
4623
|
@pulumi.input_type
|
|
3461
4624
|
class AwsIntegrationsElasticsearchArgs:
|
|
3462
4625
|
def __init__(__self__, *,
|
|
@@ -3544,6 +4707,27 @@ class AwsIntegrationsElasticsearchArgs:
|
|
|
3544
4707
|
pulumi.set(self, "tag_value", value)
|
|
3545
4708
|
|
|
3546
4709
|
|
|
4710
|
+
if not MYPY:
|
|
4711
|
+
class AwsIntegrationsElbArgsDict(TypedDict):
|
|
4712
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4713
|
+
"""
|
|
4714
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4715
|
+
"""
|
|
4716
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
4717
|
+
"""
|
|
4718
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4719
|
+
"""
|
|
4720
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4721
|
+
"""
|
|
4722
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4723
|
+
"""
|
|
4724
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4725
|
+
"""
|
|
4726
|
+
The data polling interval in seconds.
|
|
4727
|
+
"""
|
|
4728
|
+
elif False:
|
|
4729
|
+
AwsIntegrationsElbArgsDict: TypeAlias = Mapping[str, Any]
|
|
4730
|
+
|
|
3547
4731
|
@pulumi.input_type
|
|
3548
4732
|
class AwsIntegrationsElbArgs:
|
|
3549
4733
|
def __init__(__self__, *,
|
|
@@ -3615,6 +4799,31 @@ class AwsIntegrationsElbArgs:
|
|
|
3615
4799
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
3616
4800
|
|
|
3617
4801
|
|
|
4802
|
+
if not MYPY:
|
|
4803
|
+
class AwsIntegrationsEmrArgsDict(TypedDict):
|
|
4804
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4805
|
+
"""
|
|
4806
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
4807
|
+
"""
|
|
4808
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
4809
|
+
"""
|
|
4810
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
4811
|
+
"""
|
|
4812
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4813
|
+
"""
|
|
4814
|
+
The data polling interval in seconds.
|
|
4815
|
+
"""
|
|
4816
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4817
|
+
"""
|
|
4818
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4819
|
+
"""
|
|
4820
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4821
|
+
"""
|
|
4822
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4823
|
+
"""
|
|
4824
|
+
elif False:
|
|
4825
|
+
AwsIntegrationsEmrArgsDict: TypeAlias = Mapping[str, Any]
|
|
4826
|
+
|
|
3618
4827
|
@pulumi.input_type
|
|
3619
4828
|
class AwsIntegrationsEmrArgs:
|
|
3620
4829
|
def __init__(__self__, *,
|
|
@@ -3702,6 +4911,15 @@ class AwsIntegrationsEmrArgs:
|
|
|
3702
4911
|
pulumi.set(self, "tag_value", value)
|
|
3703
4912
|
|
|
3704
4913
|
|
|
4914
|
+
if not MYPY:
|
|
4915
|
+
class AwsIntegrationsHealthArgsDict(TypedDict):
|
|
4916
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4917
|
+
"""
|
|
4918
|
+
The data polling interval in seconds.
|
|
4919
|
+
"""
|
|
4920
|
+
elif False:
|
|
4921
|
+
AwsIntegrationsHealthArgsDict: TypeAlias = Mapping[str, Any]
|
|
4922
|
+
|
|
3705
4923
|
@pulumi.input_type
|
|
3706
4924
|
class AwsIntegrationsHealthArgs:
|
|
3707
4925
|
def __init__(__self__, *,
|
|
@@ -3725,6 +4943,23 @@ class AwsIntegrationsHealthArgs:
|
|
|
3725
4943
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
3726
4944
|
|
|
3727
4945
|
|
|
4946
|
+
if not MYPY:
|
|
4947
|
+
class AwsIntegrationsIamArgsDict(TypedDict):
|
|
4948
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
4949
|
+
"""
|
|
4950
|
+
The data polling interval in seconds.
|
|
4951
|
+
"""
|
|
4952
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
4953
|
+
"""
|
|
4954
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4955
|
+
"""
|
|
4956
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
4957
|
+
"""
|
|
4958
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
4959
|
+
"""
|
|
4960
|
+
elif False:
|
|
4961
|
+
AwsIntegrationsIamArgsDict: TypeAlias = Mapping[str, Any]
|
|
4962
|
+
|
|
3728
4963
|
@pulumi.input_type
|
|
3729
4964
|
class AwsIntegrationsIamArgs:
|
|
3730
4965
|
def __init__(__self__, *,
|
|
@@ -3780,6 +5015,19 @@ class AwsIntegrationsIamArgs:
|
|
|
3780
5015
|
pulumi.set(self, "tag_value", value)
|
|
3781
5016
|
|
|
3782
5017
|
|
|
5018
|
+
if not MYPY:
|
|
5019
|
+
class AwsIntegrationsIotArgsDict(TypedDict):
|
|
5020
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5021
|
+
"""
|
|
5022
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5023
|
+
"""
|
|
5024
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5025
|
+
"""
|
|
5026
|
+
The data polling interval in seconds.
|
|
5027
|
+
"""
|
|
5028
|
+
elif False:
|
|
5029
|
+
AwsIntegrationsIotArgsDict: TypeAlias = Mapping[str, Any]
|
|
5030
|
+
|
|
3783
5031
|
@pulumi.input_type
|
|
3784
5032
|
class AwsIntegrationsIotArgs:
|
|
3785
5033
|
def __init__(__self__, *,
|
|
@@ -3812,12 +5060,41 @@ class AwsIntegrationsIotArgs:
|
|
|
3812
5060
|
"""
|
|
3813
5061
|
The data polling interval in seconds.
|
|
3814
5062
|
"""
|
|
3815
|
-
return pulumi.get(self, "metrics_polling_interval")
|
|
3816
|
-
|
|
3817
|
-
@metrics_polling_interval.setter
|
|
3818
|
-
def metrics_polling_interval(self, value: Optional[pulumi.Input[int]]):
|
|
3819
|
-
pulumi.set(self, "metrics_polling_interval", value)
|
|
3820
|
-
|
|
5063
|
+
return pulumi.get(self, "metrics_polling_interval")
|
|
5064
|
+
|
|
5065
|
+
@metrics_polling_interval.setter
|
|
5066
|
+
def metrics_polling_interval(self, value: Optional[pulumi.Input[int]]):
|
|
5067
|
+
pulumi.set(self, "metrics_polling_interval", value)
|
|
5068
|
+
|
|
5069
|
+
|
|
5070
|
+
if not MYPY:
|
|
5071
|
+
class AwsIntegrationsKinesisArgsDict(TypedDict):
|
|
5072
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5073
|
+
"""
|
|
5074
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5075
|
+
"""
|
|
5076
|
+
fetch_shards: NotRequired[pulumi.Input[bool]]
|
|
5077
|
+
"""
|
|
5078
|
+
Specify if Shards should be monitored. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5079
|
+
"""
|
|
5080
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
5081
|
+
"""
|
|
5082
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5083
|
+
"""
|
|
5084
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5085
|
+
"""
|
|
5086
|
+
The data polling interval in seconds.
|
|
5087
|
+
"""
|
|
5088
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5089
|
+
"""
|
|
5090
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5091
|
+
"""
|
|
5092
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5093
|
+
"""
|
|
5094
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5095
|
+
"""
|
|
5096
|
+
elif False:
|
|
5097
|
+
AwsIntegrationsKinesisArgsDict: TypeAlias = Mapping[str, Any]
|
|
3821
5098
|
|
|
3822
5099
|
@pulumi.input_type
|
|
3823
5100
|
class AwsIntegrationsKinesisArgs:
|
|
@@ -3922,6 +5199,19 @@ class AwsIntegrationsKinesisArgs:
|
|
|
3922
5199
|
pulumi.set(self, "tag_value", value)
|
|
3923
5200
|
|
|
3924
5201
|
|
|
5202
|
+
if not MYPY:
|
|
5203
|
+
class AwsIntegrationsKinesisFirehoseArgsDict(TypedDict):
|
|
5204
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5205
|
+
"""
|
|
5206
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5207
|
+
"""
|
|
5208
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5209
|
+
"""
|
|
5210
|
+
The data polling interval in seconds.
|
|
5211
|
+
"""
|
|
5212
|
+
elif False:
|
|
5213
|
+
AwsIntegrationsKinesisFirehoseArgsDict: TypeAlias = Mapping[str, Any]
|
|
5214
|
+
|
|
3925
5215
|
@pulumi.input_type
|
|
3926
5216
|
class AwsIntegrationsKinesisFirehoseArgs:
|
|
3927
5217
|
def __init__(__self__, *,
|
|
@@ -3961,6 +5251,31 @@ class AwsIntegrationsKinesisFirehoseArgs:
|
|
|
3961
5251
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
3962
5252
|
|
|
3963
5253
|
|
|
5254
|
+
if not MYPY:
|
|
5255
|
+
class AwsIntegrationsLambdaArgsDict(TypedDict):
|
|
5256
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5257
|
+
"""
|
|
5258
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5259
|
+
"""
|
|
5260
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
5261
|
+
"""
|
|
5262
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5263
|
+
"""
|
|
5264
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5265
|
+
"""
|
|
5266
|
+
The data polling interval in seconds.
|
|
5267
|
+
"""
|
|
5268
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5269
|
+
"""
|
|
5270
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5271
|
+
"""
|
|
5272
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5273
|
+
"""
|
|
5274
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5275
|
+
"""
|
|
5276
|
+
elif False:
|
|
5277
|
+
AwsIntegrationsLambdaArgsDict: TypeAlias = Mapping[str, Any]
|
|
5278
|
+
|
|
3964
5279
|
@pulumi.input_type
|
|
3965
5280
|
class AwsIntegrationsLambdaArgs:
|
|
3966
5281
|
def __init__(__self__, *,
|
|
@@ -4048,6 +5363,31 @@ class AwsIntegrationsLambdaArgs:
|
|
|
4048
5363
|
pulumi.set(self, "tag_value", value)
|
|
4049
5364
|
|
|
4050
5365
|
|
|
5366
|
+
if not MYPY:
|
|
5367
|
+
class AwsIntegrationsRdsArgsDict(TypedDict):
|
|
5368
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5369
|
+
"""
|
|
5370
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5371
|
+
"""
|
|
5372
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
5373
|
+
"""
|
|
5374
|
+
Specify if tags and the extended inventory should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5375
|
+
"""
|
|
5376
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5377
|
+
"""
|
|
5378
|
+
The data polling interval in seconds.
|
|
5379
|
+
"""
|
|
5380
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5381
|
+
"""
|
|
5382
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5383
|
+
"""
|
|
5384
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5385
|
+
"""
|
|
5386
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5387
|
+
"""
|
|
5388
|
+
elif False:
|
|
5389
|
+
AwsIntegrationsRdsArgsDict: TypeAlias = Mapping[str, Any]
|
|
5390
|
+
|
|
4051
5391
|
@pulumi.input_type
|
|
4052
5392
|
class AwsIntegrationsRdsArgs:
|
|
4053
5393
|
def __init__(__self__, *,
|
|
@@ -4135,6 +5475,27 @@ class AwsIntegrationsRdsArgs:
|
|
|
4135
5475
|
pulumi.set(self, "tag_value", value)
|
|
4136
5476
|
|
|
4137
5477
|
|
|
5478
|
+
if not MYPY:
|
|
5479
|
+
class AwsIntegrationsRedshiftArgsDict(TypedDict):
|
|
5480
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5481
|
+
"""
|
|
5482
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5483
|
+
"""
|
|
5484
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5485
|
+
"""
|
|
5486
|
+
The data polling interval in seconds.
|
|
5487
|
+
"""
|
|
5488
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5489
|
+
"""
|
|
5490
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5491
|
+
"""
|
|
5492
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5493
|
+
"""
|
|
5494
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5495
|
+
"""
|
|
5496
|
+
elif False:
|
|
5497
|
+
AwsIntegrationsRedshiftArgsDict: TypeAlias = Mapping[str, Any]
|
|
5498
|
+
|
|
4138
5499
|
@pulumi.input_type
|
|
4139
5500
|
class AwsIntegrationsRedshiftArgs:
|
|
4140
5501
|
def __init__(__self__, *,
|
|
@@ -4206,6 +5567,19 @@ class AwsIntegrationsRedshiftArgs:
|
|
|
4206
5567
|
pulumi.set(self, "tag_value", value)
|
|
4207
5568
|
|
|
4208
5569
|
|
|
5570
|
+
if not MYPY:
|
|
5571
|
+
class AwsIntegrationsRoute53ArgsDict(TypedDict):
|
|
5572
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
5573
|
+
"""
|
|
5574
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5575
|
+
"""
|
|
5576
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5577
|
+
"""
|
|
5578
|
+
The data polling interval in seconds.
|
|
5579
|
+
"""
|
|
5580
|
+
elif False:
|
|
5581
|
+
AwsIntegrationsRoute53ArgsDict: TypeAlias = Mapping[str, Any]
|
|
5582
|
+
|
|
4209
5583
|
@pulumi.input_type
|
|
4210
5584
|
class AwsIntegrationsRoute53Args:
|
|
4211
5585
|
def __init__(__self__, *,
|
|
@@ -4245,6 +5619,31 @@ class AwsIntegrationsRoute53Args:
|
|
|
4245
5619
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
4246
5620
|
|
|
4247
5621
|
|
|
5622
|
+
if not MYPY:
|
|
5623
|
+
class AwsIntegrationsS3ArgsDict(TypedDict):
|
|
5624
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
5625
|
+
"""
|
|
5626
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5627
|
+
"""
|
|
5628
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
5629
|
+
"""
|
|
5630
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5631
|
+
"""
|
|
5632
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5633
|
+
"""
|
|
5634
|
+
The data polling interval in seconds.
|
|
5635
|
+
"""
|
|
5636
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5637
|
+
"""
|
|
5638
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5639
|
+
"""
|
|
5640
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5641
|
+
"""
|
|
5642
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5643
|
+
"""
|
|
5644
|
+
elif False:
|
|
5645
|
+
AwsIntegrationsS3ArgsDict: TypeAlias = Mapping[str, Any]
|
|
5646
|
+
|
|
4248
5647
|
@pulumi.input_type
|
|
4249
5648
|
class AwsIntegrationsS3Args:
|
|
4250
5649
|
def __init__(__self__, *,
|
|
@@ -4332,6 +5731,19 @@ class AwsIntegrationsS3Args:
|
|
|
4332
5731
|
pulumi.set(self, "tag_value", value)
|
|
4333
5732
|
|
|
4334
5733
|
|
|
5734
|
+
if not MYPY:
|
|
5735
|
+
class AwsIntegrationsSesArgsDict(TypedDict):
|
|
5736
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5737
|
+
"""
|
|
5738
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5739
|
+
"""
|
|
5740
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5741
|
+
"""
|
|
5742
|
+
The data polling interval in seconds.
|
|
5743
|
+
"""
|
|
5744
|
+
elif False:
|
|
5745
|
+
AwsIntegrationsSesArgsDict: TypeAlias = Mapping[str, Any]
|
|
5746
|
+
|
|
4335
5747
|
@pulumi.input_type
|
|
4336
5748
|
class AwsIntegrationsSesArgs:
|
|
4337
5749
|
def __init__(__self__, *,
|
|
@@ -4371,6 +5783,23 @@ class AwsIntegrationsSesArgs:
|
|
|
4371
5783
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
4372
5784
|
|
|
4373
5785
|
|
|
5786
|
+
if not MYPY:
|
|
5787
|
+
class AwsIntegrationsSnsArgsDict(TypedDict):
|
|
5788
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5789
|
+
"""
|
|
5790
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5791
|
+
"""
|
|
5792
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
5793
|
+
"""
|
|
5794
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5795
|
+
"""
|
|
5796
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5797
|
+
"""
|
|
5798
|
+
The data polling interval in seconds.
|
|
5799
|
+
"""
|
|
5800
|
+
elif False:
|
|
5801
|
+
AwsIntegrationsSnsArgsDict: TypeAlias = Mapping[str, Any]
|
|
5802
|
+
|
|
4374
5803
|
@pulumi.input_type
|
|
4375
5804
|
class AwsIntegrationsSnsArgs:
|
|
4376
5805
|
def __init__(__self__, *,
|
|
@@ -4426,6 +5855,39 @@ class AwsIntegrationsSnsArgs:
|
|
|
4426
5855
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
4427
5856
|
|
|
4428
5857
|
|
|
5858
|
+
if not MYPY:
|
|
5859
|
+
class AwsIntegrationsSqsArgsDict(TypedDict):
|
|
5860
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5861
|
+
"""
|
|
5862
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
5863
|
+
"""
|
|
5864
|
+
fetch_extended_inventory: NotRequired[pulumi.Input[bool]]
|
|
5865
|
+
"""
|
|
5866
|
+
Determine if extra inventory data be collected or not. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5867
|
+
"""
|
|
5868
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
5869
|
+
"""
|
|
5870
|
+
Specify if tags should be collected. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
5871
|
+
"""
|
|
5872
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
5873
|
+
"""
|
|
5874
|
+
The data polling interval in seconds.
|
|
5875
|
+
"""
|
|
5876
|
+
queue_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5877
|
+
"""
|
|
5878
|
+
Specify each name or prefix for the Queues that you want to monitor. Filter values are case-sensitive.
|
|
5879
|
+
"""
|
|
5880
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
5881
|
+
"""
|
|
5882
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5883
|
+
"""
|
|
5884
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
5885
|
+
"""
|
|
5886
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
5887
|
+
"""
|
|
5888
|
+
elif False:
|
|
5889
|
+
AwsIntegrationsSqsArgsDict: TypeAlias = Mapping[str, Any]
|
|
5890
|
+
|
|
4429
5891
|
@pulumi.input_type
|
|
4430
5892
|
class AwsIntegrationsSqsArgs:
|
|
4431
5893
|
def __init__(__self__, *,
|
|
@@ -4545,6 +6007,15 @@ class AwsIntegrationsSqsArgs:
|
|
|
4545
6007
|
pulumi.set(self, "tag_value", value)
|
|
4546
6008
|
|
|
4547
6009
|
|
|
6010
|
+
if not MYPY:
|
|
6011
|
+
class AwsIntegrationsTrustedAdvisorArgsDict(TypedDict):
|
|
6012
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6013
|
+
"""
|
|
6014
|
+
The data polling interval in seconds.
|
|
6015
|
+
"""
|
|
6016
|
+
elif False:
|
|
6017
|
+
AwsIntegrationsTrustedAdvisorArgsDict: TypeAlias = Mapping[str, Any]
|
|
6018
|
+
|
|
4548
6019
|
@pulumi.input_type
|
|
4549
6020
|
class AwsIntegrationsTrustedAdvisorArgs:
|
|
4550
6021
|
def __init__(__self__, *,
|
|
@@ -4568,6 +6039,35 @@ class AwsIntegrationsTrustedAdvisorArgs:
|
|
|
4568
6039
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
4569
6040
|
|
|
4570
6041
|
|
|
6042
|
+
if not MYPY:
|
|
6043
|
+
class AwsIntegrationsVpcArgsDict(TypedDict):
|
|
6044
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6045
|
+
"""
|
|
6046
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
6047
|
+
"""
|
|
6048
|
+
fetch_nat_gateway: NotRequired[pulumi.Input[bool]]
|
|
6049
|
+
"""
|
|
6050
|
+
Specify if NAT gateway should be monitored. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
6051
|
+
"""
|
|
6052
|
+
fetch_vpn: NotRequired[pulumi.Input[bool]]
|
|
6053
|
+
"""
|
|
6054
|
+
Specify if VPN should be monitored. May affect total data collection time and contribute to the Cloud provider API rate limit.
|
|
6055
|
+
"""
|
|
6056
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6057
|
+
"""
|
|
6058
|
+
The data polling interval in seconds.
|
|
6059
|
+
"""
|
|
6060
|
+
tag_key: NotRequired[pulumi.Input[str]]
|
|
6061
|
+
"""
|
|
6062
|
+
Specify a Tag key associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
6063
|
+
"""
|
|
6064
|
+
tag_value: NotRequired[pulumi.Input[str]]
|
|
6065
|
+
"""
|
|
6066
|
+
Specify a Tag value associated with the resources that you want to monitor. Filter values are case-sensitive.
|
|
6067
|
+
"""
|
|
6068
|
+
elif False:
|
|
6069
|
+
AwsIntegrationsVpcArgsDict: TypeAlias = Mapping[str, Any]
|
|
6070
|
+
|
|
4571
6071
|
@pulumi.input_type
|
|
4572
6072
|
class AwsIntegrationsVpcArgs:
|
|
4573
6073
|
def __init__(__self__, *,
|
|
@@ -4671,6 +6171,19 @@ class AwsIntegrationsVpcArgs:
|
|
|
4671
6171
|
pulumi.set(self, "tag_value", value)
|
|
4672
6172
|
|
|
4673
6173
|
|
|
6174
|
+
if not MYPY:
|
|
6175
|
+
class AwsIntegrationsXRayArgsDict(TypedDict):
|
|
6176
|
+
aws_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6177
|
+
"""
|
|
6178
|
+
Specify each AWS region that includes the resources that you want to monitor.
|
|
6179
|
+
"""
|
|
6180
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6181
|
+
"""
|
|
6182
|
+
The data polling interval in seconds.
|
|
6183
|
+
"""
|
|
6184
|
+
elif False:
|
|
6185
|
+
AwsIntegrationsXRayArgsDict: TypeAlias = Mapping[str, Any]
|
|
6186
|
+
|
|
4674
6187
|
@pulumi.input_type
|
|
4675
6188
|
class AwsIntegrationsXRayArgs:
|
|
4676
6189
|
def __init__(__self__, *,
|
|
@@ -4710,6 +6223,19 @@ class AwsIntegrationsXRayArgs:
|
|
|
4710
6223
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
4711
6224
|
|
|
4712
6225
|
|
|
6226
|
+
if not MYPY:
|
|
6227
|
+
class AzureIntegrationsApiManagementArgsDict(TypedDict):
|
|
6228
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6229
|
+
"""
|
|
6230
|
+
The data polling interval in seconds
|
|
6231
|
+
"""
|
|
6232
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6233
|
+
"""
|
|
6234
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6235
|
+
"""
|
|
6236
|
+
elif False:
|
|
6237
|
+
AzureIntegrationsApiManagementArgsDict: TypeAlias = Mapping[str, Any]
|
|
6238
|
+
|
|
4713
6239
|
@pulumi.input_type
|
|
4714
6240
|
class AzureIntegrationsApiManagementArgs:
|
|
4715
6241
|
def __init__(__self__, *,
|
|
@@ -4749,6 +6275,19 @@ class AzureIntegrationsApiManagementArgs:
|
|
|
4749
6275
|
pulumi.set(self, "resource_groups", value)
|
|
4750
6276
|
|
|
4751
6277
|
|
|
6278
|
+
if not MYPY:
|
|
6279
|
+
class AzureIntegrationsAppGatewayArgsDict(TypedDict):
|
|
6280
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6281
|
+
"""
|
|
6282
|
+
The data polling interval in seconds
|
|
6283
|
+
"""
|
|
6284
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6285
|
+
"""
|
|
6286
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6287
|
+
"""
|
|
6288
|
+
elif False:
|
|
6289
|
+
AzureIntegrationsAppGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
6290
|
+
|
|
4752
6291
|
@pulumi.input_type
|
|
4753
6292
|
class AzureIntegrationsAppGatewayArgs:
|
|
4754
6293
|
def __init__(__self__, *,
|
|
@@ -4788,6 +6327,19 @@ class AzureIntegrationsAppGatewayArgs:
|
|
|
4788
6327
|
pulumi.set(self, "resource_groups", value)
|
|
4789
6328
|
|
|
4790
6329
|
|
|
6330
|
+
if not MYPY:
|
|
6331
|
+
class AzureIntegrationsAppServiceArgsDict(TypedDict):
|
|
6332
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6333
|
+
"""
|
|
6334
|
+
The data polling interval in seconds
|
|
6335
|
+
"""
|
|
6336
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6337
|
+
"""
|
|
6338
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6339
|
+
"""
|
|
6340
|
+
elif False:
|
|
6341
|
+
AzureIntegrationsAppServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
6342
|
+
|
|
4791
6343
|
@pulumi.input_type
|
|
4792
6344
|
class AzureIntegrationsAppServiceArgs:
|
|
4793
6345
|
def __init__(__self__, *,
|
|
@@ -4827,6 +6379,19 @@ class AzureIntegrationsAppServiceArgs:
|
|
|
4827
6379
|
pulumi.set(self, "resource_groups", value)
|
|
4828
6380
|
|
|
4829
6381
|
|
|
6382
|
+
if not MYPY:
|
|
6383
|
+
class AzureIntegrationsContainersArgsDict(TypedDict):
|
|
6384
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6385
|
+
"""
|
|
6386
|
+
The data polling interval in seconds
|
|
6387
|
+
"""
|
|
6388
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6389
|
+
"""
|
|
6390
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6391
|
+
"""
|
|
6392
|
+
elif False:
|
|
6393
|
+
AzureIntegrationsContainersArgsDict: TypeAlias = Mapping[str, Any]
|
|
6394
|
+
|
|
4830
6395
|
@pulumi.input_type
|
|
4831
6396
|
class AzureIntegrationsContainersArgs:
|
|
4832
6397
|
def __init__(__self__, *,
|
|
@@ -4866,6 +6431,19 @@ class AzureIntegrationsContainersArgs:
|
|
|
4866
6431
|
pulumi.set(self, "resource_groups", value)
|
|
4867
6432
|
|
|
4868
6433
|
|
|
6434
|
+
if not MYPY:
|
|
6435
|
+
class AzureIntegrationsCosmosDbArgsDict(TypedDict):
|
|
6436
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6437
|
+
"""
|
|
6438
|
+
The data polling interval in seconds
|
|
6439
|
+
"""
|
|
6440
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6441
|
+
"""
|
|
6442
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6443
|
+
"""
|
|
6444
|
+
elif False:
|
|
6445
|
+
AzureIntegrationsCosmosDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
6446
|
+
|
|
4869
6447
|
@pulumi.input_type
|
|
4870
6448
|
class AzureIntegrationsCosmosDbArgs:
|
|
4871
6449
|
def __init__(__self__, *,
|
|
@@ -4905,6 +6483,19 @@ class AzureIntegrationsCosmosDbArgs:
|
|
|
4905
6483
|
pulumi.set(self, "resource_groups", value)
|
|
4906
6484
|
|
|
4907
6485
|
|
|
6486
|
+
if not MYPY:
|
|
6487
|
+
class AzureIntegrationsCostManagementArgsDict(TypedDict):
|
|
6488
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6489
|
+
"""
|
|
6490
|
+
The data polling interval in seconds
|
|
6491
|
+
"""
|
|
6492
|
+
tag_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6493
|
+
"""
|
|
6494
|
+
Specify if additional cost data per tag should be collected. This field is case sensitive.
|
|
6495
|
+
"""
|
|
6496
|
+
elif False:
|
|
6497
|
+
AzureIntegrationsCostManagementArgsDict: TypeAlias = Mapping[str, Any]
|
|
6498
|
+
|
|
4908
6499
|
@pulumi.input_type
|
|
4909
6500
|
class AzureIntegrationsCostManagementArgs:
|
|
4910
6501
|
def __init__(__self__, *,
|
|
@@ -4944,6 +6535,19 @@ class AzureIntegrationsCostManagementArgs:
|
|
|
4944
6535
|
pulumi.set(self, "tag_keys", value)
|
|
4945
6536
|
|
|
4946
6537
|
|
|
6538
|
+
if not MYPY:
|
|
6539
|
+
class AzureIntegrationsDataFactoryArgsDict(TypedDict):
|
|
6540
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6541
|
+
"""
|
|
6542
|
+
The data polling interval in seconds
|
|
6543
|
+
"""
|
|
6544
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6545
|
+
"""
|
|
6546
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6547
|
+
"""
|
|
6548
|
+
elif False:
|
|
6549
|
+
AzureIntegrationsDataFactoryArgsDict: TypeAlias = Mapping[str, Any]
|
|
6550
|
+
|
|
4947
6551
|
@pulumi.input_type
|
|
4948
6552
|
class AzureIntegrationsDataFactoryArgs:
|
|
4949
6553
|
def __init__(__self__, *,
|
|
@@ -4983,6 +6587,19 @@ class AzureIntegrationsDataFactoryArgs:
|
|
|
4983
6587
|
pulumi.set(self, "resource_groups", value)
|
|
4984
6588
|
|
|
4985
6589
|
|
|
6590
|
+
if not MYPY:
|
|
6591
|
+
class AzureIntegrationsEventHubArgsDict(TypedDict):
|
|
6592
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6593
|
+
"""
|
|
6594
|
+
The data polling interval in seconds
|
|
6595
|
+
"""
|
|
6596
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6597
|
+
"""
|
|
6598
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6599
|
+
"""
|
|
6600
|
+
elif False:
|
|
6601
|
+
AzureIntegrationsEventHubArgsDict: TypeAlias = Mapping[str, Any]
|
|
6602
|
+
|
|
4986
6603
|
@pulumi.input_type
|
|
4987
6604
|
class AzureIntegrationsEventHubArgs:
|
|
4988
6605
|
def __init__(__self__, *,
|
|
@@ -5022,6 +6639,19 @@ class AzureIntegrationsEventHubArgs:
|
|
|
5022
6639
|
pulumi.set(self, "resource_groups", value)
|
|
5023
6640
|
|
|
5024
6641
|
|
|
6642
|
+
if not MYPY:
|
|
6643
|
+
class AzureIntegrationsExpressRouteArgsDict(TypedDict):
|
|
6644
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6645
|
+
"""
|
|
6646
|
+
The data polling interval in seconds
|
|
6647
|
+
"""
|
|
6648
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6649
|
+
"""
|
|
6650
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6651
|
+
"""
|
|
6652
|
+
elif False:
|
|
6653
|
+
AzureIntegrationsExpressRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
6654
|
+
|
|
5025
6655
|
@pulumi.input_type
|
|
5026
6656
|
class AzureIntegrationsExpressRouteArgs:
|
|
5027
6657
|
def __init__(__self__, *,
|
|
@@ -5061,6 +6691,19 @@ class AzureIntegrationsExpressRouteArgs:
|
|
|
5061
6691
|
pulumi.set(self, "resource_groups", value)
|
|
5062
6692
|
|
|
5063
6693
|
|
|
6694
|
+
if not MYPY:
|
|
6695
|
+
class AzureIntegrationsFirewallsArgsDict(TypedDict):
|
|
6696
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6697
|
+
"""
|
|
6698
|
+
The data polling interval in seconds
|
|
6699
|
+
"""
|
|
6700
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6701
|
+
"""
|
|
6702
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6703
|
+
"""
|
|
6704
|
+
elif False:
|
|
6705
|
+
AzureIntegrationsFirewallsArgsDict: TypeAlias = Mapping[str, Any]
|
|
6706
|
+
|
|
5064
6707
|
@pulumi.input_type
|
|
5065
6708
|
class AzureIntegrationsFirewallsArgs:
|
|
5066
6709
|
def __init__(__self__, *,
|
|
@@ -5100,6 +6743,19 @@ class AzureIntegrationsFirewallsArgs:
|
|
|
5100
6743
|
pulumi.set(self, "resource_groups", value)
|
|
5101
6744
|
|
|
5102
6745
|
|
|
6746
|
+
if not MYPY:
|
|
6747
|
+
class AzureIntegrationsFrontDoorArgsDict(TypedDict):
|
|
6748
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6749
|
+
"""
|
|
6750
|
+
The data polling interval in seconds
|
|
6751
|
+
"""
|
|
6752
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6753
|
+
"""
|
|
6754
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6755
|
+
"""
|
|
6756
|
+
elif False:
|
|
6757
|
+
AzureIntegrationsFrontDoorArgsDict: TypeAlias = Mapping[str, Any]
|
|
6758
|
+
|
|
5103
6759
|
@pulumi.input_type
|
|
5104
6760
|
class AzureIntegrationsFrontDoorArgs:
|
|
5105
6761
|
def __init__(__self__, *,
|
|
@@ -5139,6 +6795,19 @@ class AzureIntegrationsFrontDoorArgs:
|
|
|
5139
6795
|
pulumi.set(self, "resource_groups", value)
|
|
5140
6796
|
|
|
5141
6797
|
|
|
6798
|
+
if not MYPY:
|
|
6799
|
+
class AzureIntegrationsFunctionsArgsDict(TypedDict):
|
|
6800
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6801
|
+
"""
|
|
6802
|
+
The data polling interval in seconds
|
|
6803
|
+
"""
|
|
6804
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6805
|
+
"""
|
|
6806
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6807
|
+
"""
|
|
6808
|
+
elif False:
|
|
6809
|
+
AzureIntegrationsFunctionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
6810
|
+
|
|
5142
6811
|
@pulumi.input_type
|
|
5143
6812
|
class AzureIntegrationsFunctionsArgs:
|
|
5144
6813
|
def __init__(__self__, *,
|
|
@@ -5178,6 +6847,19 @@ class AzureIntegrationsFunctionsArgs:
|
|
|
5178
6847
|
pulumi.set(self, "resource_groups", value)
|
|
5179
6848
|
|
|
5180
6849
|
|
|
6850
|
+
if not MYPY:
|
|
6851
|
+
class AzureIntegrationsKeyVaultArgsDict(TypedDict):
|
|
6852
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6853
|
+
"""
|
|
6854
|
+
The data polling interval in seconds
|
|
6855
|
+
"""
|
|
6856
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6857
|
+
"""
|
|
6858
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6859
|
+
"""
|
|
6860
|
+
elif False:
|
|
6861
|
+
AzureIntegrationsKeyVaultArgsDict: TypeAlias = Mapping[str, Any]
|
|
6862
|
+
|
|
5181
6863
|
@pulumi.input_type
|
|
5182
6864
|
class AzureIntegrationsKeyVaultArgs:
|
|
5183
6865
|
def __init__(__self__, *,
|
|
@@ -5217,6 +6899,19 @@ class AzureIntegrationsKeyVaultArgs:
|
|
|
5217
6899
|
pulumi.set(self, "resource_groups", value)
|
|
5218
6900
|
|
|
5219
6901
|
|
|
6902
|
+
if not MYPY:
|
|
6903
|
+
class AzureIntegrationsLoadBalancerArgsDict(TypedDict):
|
|
6904
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6905
|
+
"""
|
|
6906
|
+
The data polling interval in seconds
|
|
6907
|
+
"""
|
|
6908
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6909
|
+
"""
|
|
6910
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6911
|
+
"""
|
|
6912
|
+
elif False:
|
|
6913
|
+
AzureIntegrationsLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
|
|
6914
|
+
|
|
5220
6915
|
@pulumi.input_type
|
|
5221
6916
|
class AzureIntegrationsLoadBalancerArgs:
|
|
5222
6917
|
def __init__(__self__, *,
|
|
@@ -5256,6 +6951,19 @@ class AzureIntegrationsLoadBalancerArgs:
|
|
|
5256
6951
|
pulumi.set(self, "resource_groups", value)
|
|
5257
6952
|
|
|
5258
6953
|
|
|
6954
|
+
if not MYPY:
|
|
6955
|
+
class AzureIntegrationsLogicAppsArgsDict(TypedDict):
|
|
6956
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
6957
|
+
"""
|
|
6958
|
+
The data polling interval in seconds
|
|
6959
|
+
"""
|
|
6960
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6961
|
+
"""
|
|
6962
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
6963
|
+
"""
|
|
6964
|
+
elif False:
|
|
6965
|
+
AzureIntegrationsLogicAppsArgsDict: TypeAlias = Mapping[str, Any]
|
|
6966
|
+
|
|
5259
6967
|
@pulumi.input_type
|
|
5260
6968
|
class AzureIntegrationsLogicAppsArgs:
|
|
5261
6969
|
def __init__(__self__, *,
|
|
@@ -5295,6 +7003,19 @@ class AzureIntegrationsLogicAppsArgs:
|
|
|
5295
7003
|
pulumi.set(self, "resource_groups", value)
|
|
5296
7004
|
|
|
5297
7005
|
|
|
7006
|
+
if not MYPY:
|
|
7007
|
+
class AzureIntegrationsMachineLearningArgsDict(TypedDict):
|
|
7008
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7009
|
+
"""
|
|
7010
|
+
The data polling interval in seconds
|
|
7011
|
+
"""
|
|
7012
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7013
|
+
"""
|
|
7014
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7015
|
+
"""
|
|
7016
|
+
elif False:
|
|
7017
|
+
AzureIntegrationsMachineLearningArgsDict: TypeAlias = Mapping[str, Any]
|
|
7018
|
+
|
|
5298
7019
|
@pulumi.input_type
|
|
5299
7020
|
class AzureIntegrationsMachineLearningArgs:
|
|
5300
7021
|
def __init__(__self__, *,
|
|
@@ -5334,6 +7055,19 @@ class AzureIntegrationsMachineLearningArgs:
|
|
|
5334
7055
|
pulumi.set(self, "resource_groups", value)
|
|
5335
7056
|
|
|
5336
7057
|
|
|
7058
|
+
if not MYPY:
|
|
7059
|
+
class AzureIntegrationsMariaDbArgsDict(TypedDict):
|
|
7060
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7061
|
+
"""
|
|
7062
|
+
The data polling interval in seconds
|
|
7063
|
+
"""
|
|
7064
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7065
|
+
"""
|
|
7066
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7067
|
+
"""
|
|
7068
|
+
elif False:
|
|
7069
|
+
AzureIntegrationsMariaDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
7070
|
+
|
|
5337
7071
|
@pulumi.input_type
|
|
5338
7072
|
class AzureIntegrationsMariaDbArgs:
|
|
5339
7073
|
def __init__(__self__, *,
|
|
@@ -5373,6 +7107,35 @@ class AzureIntegrationsMariaDbArgs:
|
|
|
5373
7107
|
pulumi.set(self, "resource_groups", value)
|
|
5374
7108
|
|
|
5375
7109
|
|
|
7110
|
+
if not MYPY:
|
|
7111
|
+
class AzureIntegrationsMonitorArgsDict(TypedDict):
|
|
7112
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
7113
|
+
"""
|
|
7114
|
+
A flag that specifies if the integration is active
|
|
7115
|
+
"""
|
|
7116
|
+
exclude_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7117
|
+
"""
|
|
7118
|
+
Specify resource tags in 'key:value' form to be excluded from monitoring
|
|
7119
|
+
"""
|
|
7120
|
+
include_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7121
|
+
"""
|
|
7122
|
+
Specify resource tags in 'key:value' form to be monitored
|
|
7123
|
+
"""
|
|
7124
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7125
|
+
"""
|
|
7126
|
+
The data polling interval in seconds
|
|
7127
|
+
"""
|
|
7128
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7129
|
+
"""
|
|
7130
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7131
|
+
"""
|
|
7132
|
+
resource_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7133
|
+
"""
|
|
7134
|
+
Specify each Azure resource type that needs to be monitored
|
|
7135
|
+
"""
|
|
7136
|
+
elif False:
|
|
7137
|
+
AzureIntegrationsMonitorArgsDict: TypeAlias = Mapping[str, Any]
|
|
7138
|
+
|
|
5376
7139
|
@pulumi.input_type
|
|
5377
7140
|
class AzureIntegrationsMonitorArgs:
|
|
5378
7141
|
def __init__(__self__, *,
|
|
@@ -5476,6 +7239,19 @@ class AzureIntegrationsMonitorArgs:
|
|
|
5476
7239
|
pulumi.set(self, "resource_types", value)
|
|
5477
7240
|
|
|
5478
7241
|
|
|
7242
|
+
if not MYPY:
|
|
7243
|
+
class AzureIntegrationsMysqlArgsDict(TypedDict):
|
|
7244
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7245
|
+
"""
|
|
7246
|
+
The data polling interval in seconds
|
|
7247
|
+
"""
|
|
7248
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7249
|
+
"""
|
|
7250
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7251
|
+
"""
|
|
7252
|
+
elif False:
|
|
7253
|
+
AzureIntegrationsMysqlArgsDict: TypeAlias = Mapping[str, Any]
|
|
7254
|
+
|
|
5479
7255
|
@pulumi.input_type
|
|
5480
7256
|
class AzureIntegrationsMysqlArgs:
|
|
5481
7257
|
def __init__(__self__, *,
|
|
@@ -5515,6 +7291,19 @@ class AzureIntegrationsMysqlArgs:
|
|
|
5515
7291
|
pulumi.set(self, "resource_groups", value)
|
|
5516
7292
|
|
|
5517
7293
|
|
|
7294
|
+
if not MYPY:
|
|
7295
|
+
class AzureIntegrationsMysqlFlexibleArgsDict(TypedDict):
|
|
7296
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7297
|
+
"""
|
|
7298
|
+
The data polling interval in seconds
|
|
7299
|
+
"""
|
|
7300
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7301
|
+
"""
|
|
7302
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7303
|
+
"""
|
|
7304
|
+
elif False:
|
|
7305
|
+
AzureIntegrationsMysqlFlexibleArgsDict: TypeAlias = Mapping[str, Any]
|
|
7306
|
+
|
|
5518
7307
|
@pulumi.input_type
|
|
5519
7308
|
class AzureIntegrationsMysqlFlexibleArgs:
|
|
5520
7309
|
def __init__(__self__, *,
|
|
@@ -5554,6 +7343,19 @@ class AzureIntegrationsMysqlFlexibleArgs:
|
|
|
5554
7343
|
pulumi.set(self, "resource_groups", value)
|
|
5555
7344
|
|
|
5556
7345
|
|
|
7346
|
+
if not MYPY:
|
|
7347
|
+
class AzureIntegrationsPostgresqlArgsDict(TypedDict):
|
|
7348
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7349
|
+
"""
|
|
7350
|
+
The data polling interval in seconds
|
|
7351
|
+
"""
|
|
7352
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7353
|
+
"""
|
|
7354
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7355
|
+
"""
|
|
7356
|
+
elif False:
|
|
7357
|
+
AzureIntegrationsPostgresqlArgsDict: TypeAlias = Mapping[str, Any]
|
|
7358
|
+
|
|
5557
7359
|
@pulumi.input_type
|
|
5558
7360
|
class AzureIntegrationsPostgresqlArgs:
|
|
5559
7361
|
def __init__(__self__, *,
|
|
@@ -5593,6 +7395,19 @@ class AzureIntegrationsPostgresqlArgs:
|
|
|
5593
7395
|
pulumi.set(self, "resource_groups", value)
|
|
5594
7396
|
|
|
5595
7397
|
|
|
7398
|
+
if not MYPY:
|
|
7399
|
+
class AzureIntegrationsPostgresqlFlexibleArgsDict(TypedDict):
|
|
7400
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7401
|
+
"""
|
|
7402
|
+
The data polling interval in seconds
|
|
7403
|
+
"""
|
|
7404
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7405
|
+
"""
|
|
7406
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7407
|
+
"""
|
|
7408
|
+
elif False:
|
|
7409
|
+
AzureIntegrationsPostgresqlFlexibleArgsDict: TypeAlias = Mapping[str, Any]
|
|
7410
|
+
|
|
5596
7411
|
@pulumi.input_type
|
|
5597
7412
|
class AzureIntegrationsPostgresqlFlexibleArgs:
|
|
5598
7413
|
def __init__(__self__, *,
|
|
@@ -5632,6 +7447,19 @@ class AzureIntegrationsPostgresqlFlexibleArgs:
|
|
|
5632
7447
|
pulumi.set(self, "resource_groups", value)
|
|
5633
7448
|
|
|
5634
7449
|
|
|
7450
|
+
if not MYPY:
|
|
7451
|
+
class AzureIntegrationsPowerBiDedicatedArgsDict(TypedDict):
|
|
7452
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7453
|
+
"""
|
|
7454
|
+
The data polling interval in seconds
|
|
7455
|
+
"""
|
|
7456
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7457
|
+
"""
|
|
7458
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7459
|
+
"""
|
|
7460
|
+
elif False:
|
|
7461
|
+
AzureIntegrationsPowerBiDedicatedArgsDict: TypeAlias = Mapping[str, Any]
|
|
7462
|
+
|
|
5635
7463
|
@pulumi.input_type
|
|
5636
7464
|
class AzureIntegrationsPowerBiDedicatedArgs:
|
|
5637
7465
|
def __init__(__self__, *,
|
|
@@ -5671,6 +7499,19 @@ class AzureIntegrationsPowerBiDedicatedArgs:
|
|
|
5671
7499
|
pulumi.set(self, "resource_groups", value)
|
|
5672
7500
|
|
|
5673
7501
|
|
|
7502
|
+
if not MYPY:
|
|
7503
|
+
class AzureIntegrationsRedisCacheArgsDict(TypedDict):
|
|
7504
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7505
|
+
"""
|
|
7506
|
+
The data polling interval in seconds
|
|
7507
|
+
"""
|
|
7508
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7509
|
+
"""
|
|
7510
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7511
|
+
"""
|
|
7512
|
+
elif False:
|
|
7513
|
+
AzureIntegrationsRedisCacheArgsDict: TypeAlias = Mapping[str, Any]
|
|
7514
|
+
|
|
5674
7515
|
@pulumi.input_type
|
|
5675
7516
|
class AzureIntegrationsRedisCacheArgs:
|
|
5676
7517
|
def __init__(__self__, *,
|
|
@@ -5710,6 +7551,19 @@ class AzureIntegrationsRedisCacheArgs:
|
|
|
5710
7551
|
pulumi.set(self, "resource_groups", value)
|
|
5711
7552
|
|
|
5712
7553
|
|
|
7554
|
+
if not MYPY:
|
|
7555
|
+
class AzureIntegrationsServiceBusArgsDict(TypedDict):
|
|
7556
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7557
|
+
"""
|
|
7558
|
+
The data polling interval in seconds
|
|
7559
|
+
"""
|
|
7560
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7561
|
+
"""
|
|
7562
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7563
|
+
"""
|
|
7564
|
+
elif False:
|
|
7565
|
+
AzureIntegrationsServiceBusArgsDict: TypeAlias = Mapping[str, Any]
|
|
7566
|
+
|
|
5713
7567
|
@pulumi.input_type
|
|
5714
7568
|
class AzureIntegrationsServiceBusArgs:
|
|
5715
7569
|
def __init__(__self__, *,
|
|
@@ -5749,6 +7603,19 @@ class AzureIntegrationsServiceBusArgs:
|
|
|
5749
7603
|
pulumi.set(self, "resource_groups", value)
|
|
5750
7604
|
|
|
5751
7605
|
|
|
7606
|
+
if not MYPY:
|
|
7607
|
+
class AzureIntegrationsSqlArgsDict(TypedDict):
|
|
7608
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7609
|
+
"""
|
|
7610
|
+
The data polling interval in seconds
|
|
7611
|
+
"""
|
|
7612
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7613
|
+
"""
|
|
7614
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7615
|
+
"""
|
|
7616
|
+
elif False:
|
|
7617
|
+
AzureIntegrationsSqlArgsDict: TypeAlias = Mapping[str, Any]
|
|
7618
|
+
|
|
5752
7619
|
@pulumi.input_type
|
|
5753
7620
|
class AzureIntegrationsSqlArgs:
|
|
5754
7621
|
def __init__(__self__, *,
|
|
@@ -5788,6 +7655,19 @@ class AzureIntegrationsSqlArgs:
|
|
|
5788
7655
|
pulumi.set(self, "resource_groups", value)
|
|
5789
7656
|
|
|
5790
7657
|
|
|
7658
|
+
if not MYPY:
|
|
7659
|
+
class AzureIntegrationsSqlManagedArgsDict(TypedDict):
|
|
7660
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7661
|
+
"""
|
|
7662
|
+
The data polling interval in seconds
|
|
7663
|
+
"""
|
|
7664
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7665
|
+
"""
|
|
7666
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7667
|
+
"""
|
|
7668
|
+
elif False:
|
|
7669
|
+
AzureIntegrationsSqlManagedArgsDict: TypeAlias = Mapping[str, Any]
|
|
7670
|
+
|
|
5791
7671
|
@pulumi.input_type
|
|
5792
7672
|
class AzureIntegrationsSqlManagedArgs:
|
|
5793
7673
|
def __init__(__self__, *,
|
|
@@ -5827,6 +7707,19 @@ class AzureIntegrationsSqlManagedArgs:
|
|
|
5827
7707
|
pulumi.set(self, "resource_groups", value)
|
|
5828
7708
|
|
|
5829
7709
|
|
|
7710
|
+
if not MYPY:
|
|
7711
|
+
class AzureIntegrationsStorageArgsDict(TypedDict):
|
|
7712
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7713
|
+
"""
|
|
7714
|
+
The data polling interval in seconds
|
|
7715
|
+
"""
|
|
7716
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7717
|
+
"""
|
|
7718
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7719
|
+
"""
|
|
7720
|
+
elif False:
|
|
7721
|
+
AzureIntegrationsStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
7722
|
+
|
|
5830
7723
|
@pulumi.input_type
|
|
5831
7724
|
class AzureIntegrationsStorageArgs:
|
|
5832
7725
|
def __init__(__self__, *,
|
|
@@ -5866,6 +7759,19 @@ class AzureIntegrationsStorageArgs:
|
|
|
5866
7759
|
pulumi.set(self, "resource_groups", value)
|
|
5867
7760
|
|
|
5868
7761
|
|
|
7762
|
+
if not MYPY:
|
|
7763
|
+
class AzureIntegrationsVirtualMachineArgsDict(TypedDict):
|
|
7764
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7765
|
+
"""
|
|
7766
|
+
The data polling interval in seconds
|
|
7767
|
+
"""
|
|
7768
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7769
|
+
"""
|
|
7770
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7771
|
+
"""
|
|
7772
|
+
elif False:
|
|
7773
|
+
AzureIntegrationsVirtualMachineArgsDict: TypeAlias = Mapping[str, Any]
|
|
7774
|
+
|
|
5869
7775
|
@pulumi.input_type
|
|
5870
7776
|
class AzureIntegrationsVirtualMachineArgs:
|
|
5871
7777
|
def __init__(__self__, *,
|
|
@@ -5905,6 +7811,19 @@ class AzureIntegrationsVirtualMachineArgs:
|
|
|
5905
7811
|
pulumi.set(self, "resource_groups", value)
|
|
5906
7812
|
|
|
5907
7813
|
|
|
7814
|
+
if not MYPY:
|
|
7815
|
+
class AzureIntegrationsVirtualNetworksArgsDict(TypedDict):
|
|
7816
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7817
|
+
"""
|
|
7818
|
+
The data polling interval in seconds
|
|
7819
|
+
"""
|
|
7820
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7821
|
+
"""
|
|
7822
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7823
|
+
"""
|
|
7824
|
+
elif False:
|
|
7825
|
+
AzureIntegrationsVirtualNetworksArgsDict: TypeAlias = Mapping[str, Any]
|
|
7826
|
+
|
|
5908
7827
|
@pulumi.input_type
|
|
5909
7828
|
class AzureIntegrationsVirtualNetworksArgs:
|
|
5910
7829
|
def __init__(__self__, *,
|
|
@@ -5944,6 +7863,19 @@ class AzureIntegrationsVirtualNetworksArgs:
|
|
|
5944
7863
|
pulumi.set(self, "resource_groups", value)
|
|
5945
7864
|
|
|
5946
7865
|
|
|
7866
|
+
if not MYPY:
|
|
7867
|
+
class AzureIntegrationsVmsArgsDict(TypedDict):
|
|
7868
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7869
|
+
"""
|
|
7870
|
+
The data polling interval in seconds
|
|
7871
|
+
"""
|
|
7872
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7873
|
+
"""
|
|
7874
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7875
|
+
"""
|
|
7876
|
+
elif False:
|
|
7877
|
+
AzureIntegrationsVmsArgsDict: TypeAlias = Mapping[str, Any]
|
|
7878
|
+
|
|
5947
7879
|
@pulumi.input_type
|
|
5948
7880
|
class AzureIntegrationsVmsArgs:
|
|
5949
7881
|
def __init__(__self__, *,
|
|
@@ -5983,6 +7915,19 @@ class AzureIntegrationsVmsArgs:
|
|
|
5983
7915
|
pulumi.set(self, "resource_groups", value)
|
|
5984
7916
|
|
|
5985
7917
|
|
|
7918
|
+
if not MYPY:
|
|
7919
|
+
class AzureIntegrationsVpnGatewayArgsDict(TypedDict):
|
|
7920
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7921
|
+
"""
|
|
7922
|
+
The data polling interval in seconds
|
|
7923
|
+
"""
|
|
7924
|
+
resource_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
7925
|
+
"""
|
|
7926
|
+
Specify each Resource group associated with the resources that you want to monitor. Filter values are case-sensitive
|
|
7927
|
+
"""
|
|
7928
|
+
elif False:
|
|
7929
|
+
AzureIntegrationsVpnGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
7930
|
+
|
|
5986
7931
|
@pulumi.input_type
|
|
5987
7932
|
class AzureIntegrationsVpnGatewayArgs:
|
|
5988
7933
|
def __init__(__self__, *,
|
|
@@ -6022,6 +7967,15 @@ class AzureIntegrationsVpnGatewayArgs:
|
|
|
6022
7967
|
pulumi.set(self, "resource_groups", value)
|
|
6023
7968
|
|
|
6024
7969
|
|
|
7970
|
+
if not MYPY:
|
|
7971
|
+
class GcpIntegrationsAlloyDbArgsDict(TypedDict):
|
|
7972
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
7973
|
+
"""
|
|
7974
|
+
the data polling interval in seconds
|
|
7975
|
+
"""
|
|
7976
|
+
elif False:
|
|
7977
|
+
GcpIntegrationsAlloyDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
7978
|
+
|
|
6025
7979
|
@pulumi.input_type
|
|
6026
7980
|
class GcpIntegrationsAlloyDbArgs:
|
|
6027
7981
|
def __init__(__self__, *,
|
|
@@ -6045,6 +7999,15 @@ class GcpIntegrationsAlloyDbArgs:
|
|
|
6045
7999
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6046
8000
|
|
|
6047
8001
|
|
|
8002
|
+
if not MYPY:
|
|
8003
|
+
class GcpIntegrationsAppEngineArgsDict(TypedDict):
|
|
8004
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8005
|
+
"""
|
|
8006
|
+
the data polling interval in seconds
|
|
8007
|
+
"""
|
|
8008
|
+
elif False:
|
|
8009
|
+
GcpIntegrationsAppEngineArgsDict: TypeAlias = Mapping[str, Any]
|
|
8010
|
+
|
|
6048
8011
|
@pulumi.input_type
|
|
6049
8012
|
class GcpIntegrationsAppEngineArgs:
|
|
6050
8013
|
def __init__(__self__, *,
|
|
@@ -6068,6 +8031,19 @@ class GcpIntegrationsAppEngineArgs:
|
|
|
6068
8031
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6069
8032
|
|
|
6070
8033
|
|
|
8034
|
+
if not MYPY:
|
|
8035
|
+
class GcpIntegrationsBigQueryArgsDict(TypedDict):
|
|
8036
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
8037
|
+
"""
|
|
8038
|
+
to fetch tags of the resource
|
|
8039
|
+
"""
|
|
8040
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8041
|
+
"""
|
|
8042
|
+
the data polling interval in seconds
|
|
8043
|
+
"""
|
|
8044
|
+
elif False:
|
|
8045
|
+
GcpIntegrationsBigQueryArgsDict: TypeAlias = Mapping[str, Any]
|
|
8046
|
+
|
|
6071
8047
|
@pulumi.input_type
|
|
6072
8048
|
class GcpIntegrationsBigQueryArgs:
|
|
6073
8049
|
def __init__(__self__, *,
|
|
@@ -6107,6 +8083,15 @@ class GcpIntegrationsBigQueryArgs:
|
|
|
6107
8083
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6108
8084
|
|
|
6109
8085
|
|
|
8086
|
+
if not MYPY:
|
|
8087
|
+
class GcpIntegrationsBigTableArgsDict(TypedDict):
|
|
8088
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8089
|
+
"""
|
|
8090
|
+
the data polling interval in seconds
|
|
8091
|
+
"""
|
|
8092
|
+
elif False:
|
|
8093
|
+
GcpIntegrationsBigTableArgsDict: TypeAlias = Mapping[str, Any]
|
|
8094
|
+
|
|
6110
8095
|
@pulumi.input_type
|
|
6111
8096
|
class GcpIntegrationsBigTableArgs:
|
|
6112
8097
|
def __init__(__self__, *,
|
|
@@ -6130,6 +8115,15 @@ class GcpIntegrationsBigTableArgs:
|
|
|
6130
8115
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6131
8116
|
|
|
6132
8117
|
|
|
8118
|
+
if not MYPY:
|
|
8119
|
+
class GcpIntegrationsComposerArgsDict(TypedDict):
|
|
8120
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8121
|
+
"""
|
|
8122
|
+
the data polling interval in seconds
|
|
8123
|
+
"""
|
|
8124
|
+
elif False:
|
|
8125
|
+
GcpIntegrationsComposerArgsDict: TypeAlias = Mapping[str, Any]
|
|
8126
|
+
|
|
6133
8127
|
@pulumi.input_type
|
|
6134
8128
|
class GcpIntegrationsComposerArgs:
|
|
6135
8129
|
def __init__(__self__, *,
|
|
@@ -6153,6 +8147,15 @@ class GcpIntegrationsComposerArgs:
|
|
|
6153
8147
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6154
8148
|
|
|
6155
8149
|
|
|
8150
|
+
if not MYPY:
|
|
8151
|
+
class GcpIntegrationsDataFlowArgsDict(TypedDict):
|
|
8152
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8153
|
+
"""
|
|
8154
|
+
the data polling interval in seconds
|
|
8155
|
+
"""
|
|
8156
|
+
elif False:
|
|
8157
|
+
GcpIntegrationsDataFlowArgsDict: TypeAlias = Mapping[str, Any]
|
|
8158
|
+
|
|
6156
8159
|
@pulumi.input_type
|
|
6157
8160
|
class GcpIntegrationsDataFlowArgs:
|
|
6158
8161
|
def __init__(__self__, *,
|
|
@@ -6176,6 +8179,15 @@ class GcpIntegrationsDataFlowArgs:
|
|
|
6176
8179
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6177
8180
|
|
|
6178
8181
|
|
|
8182
|
+
if not MYPY:
|
|
8183
|
+
class GcpIntegrationsDataProcArgsDict(TypedDict):
|
|
8184
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8185
|
+
"""
|
|
8186
|
+
the data polling interval in seconds
|
|
8187
|
+
"""
|
|
8188
|
+
elif False:
|
|
8189
|
+
GcpIntegrationsDataProcArgsDict: TypeAlias = Mapping[str, Any]
|
|
8190
|
+
|
|
6179
8191
|
@pulumi.input_type
|
|
6180
8192
|
class GcpIntegrationsDataProcArgs:
|
|
6181
8193
|
def __init__(__self__, *,
|
|
@@ -6199,6 +8211,15 @@ class GcpIntegrationsDataProcArgs:
|
|
|
6199
8211
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6200
8212
|
|
|
6201
8213
|
|
|
8214
|
+
if not MYPY:
|
|
8215
|
+
class GcpIntegrationsDataStoreArgsDict(TypedDict):
|
|
8216
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8217
|
+
"""
|
|
8218
|
+
the data polling interval in seconds
|
|
8219
|
+
"""
|
|
8220
|
+
elif False:
|
|
8221
|
+
GcpIntegrationsDataStoreArgsDict: TypeAlias = Mapping[str, Any]
|
|
8222
|
+
|
|
6202
8223
|
@pulumi.input_type
|
|
6203
8224
|
class GcpIntegrationsDataStoreArgs:
|
|
6204
8225
|
def __init__(__self__, *,
|
|
@@ -6222,6 +8243,15 @@ class GcpIntegrationsDataStoreArgs:
|
|
|
6222
8243
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6223
8244
|
|
|
6224
8245
|
|
|
8246
|
+
if not MYPY:
|
|
8247
|
+
class GcpIntegrationsFireBaseDatabaseArgsDict(TypedDict):
|
|
8248
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8249
|
+
"""
|
|
8250
|
+
the data polling interval in seconds
|
|
8251
|
+
"""
|
|
8252
|
+
elif False:
|
|
8253
|
+
GcpIntegrationsFireBaseDatabaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
8254
|
+
|
|
6225
8255
|
@pulumi.input_type
|
|
6226
8256
|
class GcpIntegrationsFireBaseDatabaseArgs:
|
|
6227
8257
|
def __init__(__self__, *,
|
|
@@ -6245,6 +8275,15 @@ class GcpIntegrationsFireBaseDatabaseArgs:
|
|
|
6245
8275
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6246
8276
|
|
|
6247
8277
|
|
|
8278
|
+
if not MYPY:
|
|
8279
|
+
class GcpIntegrationsFireBaseHostingArgsDict(TypedDict):
|
|
8280
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8281
|
+
"""
|
|
8282
|
+
the data polling interval in seconds
|
|
8283
|
+
"""
|
|
8284
|
+
elif False:
|
|
8285
|
+
GcpIntegrationsFireBaseHostingArgsDict: TypeAlias = Mapping[str, Any]
|
|
8286
|
+
|
|
6248
8287
|
@pulumi.input_type
|
|
6249
8288
|
class GcpIntegrationsFireBaseHostingArgs:
|
|
6250
8289
|
def __init__(__self__, *,
|
|
@@ -6268,6 +8307,15 @@ class GcpIntegrationsFireBaseHostingArgs:
|
|
|
6268
8307
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6269
8308
|
|
|
6270
8309
|
|
|
8310
|
+
if not MYPY:
|
|
8311
|
+
class GcpIntegrationsFireBaseStorageArgsDict(TypedDict):
|
|
8312
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8313
|
+
"""
|
|
8314
|
+
the data polling interval in seconds
|
|
8315
|
+
"""
|
|
8316
|
+
elif False:
|
|
8317
|
+
GcpIntegrationsFireBaseStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
8318
|
+
|
|
6271
8319
|
@pulumi.input_type
|
|
6272
8320
|
class GcpIntegrationsFireBaseStorageArgs:
|
|
6273
8321
|
def __init__(__self__, *,
|
|
@@ -6291,6 +8339,15 @@ class GcpIntegrationsFireBaseStorageArgs:
|
|
|
6291
8339
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6292
8340
|
|
|
6293
8341
|
|
|
8342
|
+
if not MYPY:
|
|
8343
|
+
class GcpIntegrationsFireStoreArgsDict(TypedDict):
|
|
8344
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8345
|
+
"""
|
|
8346
|
+
the data polling interval in seconds
|
|
8347
|
+
"""
|
|
8348
|
+
elif False:
|
|
8349
|
+
GcpIntegrationsFireStoreArgsDict: TypeAlias = Mapping[str, Any]
|
|
8350
|
+
|
|
6294
8351
|
@pulumi.input_type
|
|
6295
8352
|
class GcpIntegrationsFireStoreArgs:
|
|
6296
8353
|
def __init__(__self__, *,
|
|
@@ -6314,6 +8371,15 @@ class GcpIntegrationsFireStoreArgs:
|
|
|
6314
8371
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6315
8372
|
|
|
6316
8373
|
|
|
8374
|
+
if not MYPY:
|
|
8375
|
+
class GcpIntegrationsFunctionsArgsDict(TypedDict):
|
|
8376
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8377
|
+
"""
|
|
8378
|
+
the data polling interval in seconds
|
|
8379
|
+
"""
|
|
8380
|
+
elif False:
|
|
8381
|
+
GcpIntegrationsFunctionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
8382
|
+
|
|
6317
8383
|
@pulumi.input_type
|
|
6318
8384
|
class GcpIntegrationsFunctionsArgs:
|
|
6319
8385
|
def __init__(__self__, *,
|
|
@@ -6337,6 +8403,15 @@ class GcpIntegrationsFunctionsArgs:
|
|
|
6337
8403
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6338
8404
|
|
|
6339
8405
|
|
|
8406
|
+
if not MYPY:
|
|
8407
|
+
class GcpIntegrationsInterconnectArgsDict(TypedDict):
|
|
8408
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8409
|
+
"""
|
|
8410
|
+
the data polling interval in seconds
|
|
8411
|
+
"""
|
|
8412
|
+
elif False:
|
|
8413
|
+
GcpIntegrationsInterconnectArgsDict: TypeAlias = Mapping[str, Any]
|
|
8414
|
+
|
|
6340
8415
|
@pulumi.input_type
|
|
6341
8416
|
class GcpIntegrationsInterconnectArgs:
|
|
6342
8417
|
def __init__(__self__, *,
|
|
@@ -6360,6 +8435,15 @@ class GcpIntegrationsInterconnectArgs:
|
|
|
6360
8435
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6361
8436
|
|
|
6362
8437
|
|
|
8438
|
+
if not MYPY:
|
|
8439
|
+
class GcpIntegrationsKubernetesArgsDict(TypedDict):
|
|
8440
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8441
|
+
"""
|
|
8442
|
+
the data polling interval in seconds
|
|
8443
|
+
"""
|
|
8444
|
+
elif False:
|
|
8445
|
+
GcpIntegrationsKubernetesArgsDict: TypeAlias = Mapping[str, Any]
|
|
8446
|
+
|
|
6363
8447
|
@pulumi.input_type
|
|
6364
8448
|
class GcpIntegrationsKubernetesArgs:
|
|
6365
8449
|
def __init__(__self__, *,
|
|
@@ -6383,6 +8467,15 @@ class GcpIntegrationsKubernetesArgs:
|
|
|
6383
8467
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6384
8468
|
|
|
6385
8469
|
|
|
8470
|
+
if not MYPY:
|
|
8471
|
+
class GcpIntegrationsLoadBalancingArgsDict(TypedDict):
|
|
8472
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8473
|
+
"""
|
|
8474
|
+
the data polling interval in seconds
|
|
8475
|
+
"""
|
|
8476
|
+
elif False:
|
|
8477
|
+
GcpIntegrationsLoadBalancingArgsDict: TypeAlias = Mapping[str, Any]
|
|
8478
|
+
|
|
6386
8479
|
@pulumi.input_type
|
|
6387
8480
|
class GcpIntegrationsLoadBalancingArgs:
|
|
6388
8481
|
def __init__(__self__, *,
|
|
@@ -6406,6 +8499,15 @@ class GcpIntegrationsLoadBalancingArgs:
|
|
|
6406
8499
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6407
8500
|
|
|
6408
8501
|
|
|
8502
|
+
if not MYPY:
|
|
8503
|
+
class GcpIntegrationsMemCacheArgsDict(TypedDict):
|
|
8504
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8505
|
+
"""
|
|
8506
|
+
the data polling interval in seconds
|
|
8507
|
+
"""
|
|
8508
|
+
elif False:
|
|
8509
|
+
GcpIntegrationsMemCacheArgsDict: TypeAlias = Mapping[str, Any]
|
|
8510
|
+
|
|
6409
8511
|
@pulumi.input_type
|
|
6410
8512
|
class GcpIntegrationsMemCacheArgs:
|
|
6411
8513
|
def __init__(__self__, *,
|
|
@@ -6429,6 +8531,19 @@ class GcpIntegrationsMemCacheArgs:
|
|
|
6429
8531
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6430
8532
|
|
|
6431
8533
|
|
|
8534
|
+
if not MYPY:
|
|
8535
|
+
class GcpIntegrationsPubSubArgsDict(TypedDict):
|
|
8536
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
8537
|
+
"""
|
|
8538
|
+
to fetch tags of the resource
|
|
8539
|
+
"""
|
|
8540
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8541
|
+
"""
|
|
8542
|
+
the data polling interval in seconds
|
|
8543
|
+
"""
|
|
8544
|
+
elif False:
|
|
8545
|
+
GcpIntegrationsPubSubArgsDict: TypeAlias = Mapping[str, Any]
|
|
8546
|
+
|
|
6432
8547
|
@pulumi.input_type
|
|
6433
8548
|
class GcpIntegrationsPubSubArgs:
|
|
6434
8549
|
def __init__(__self__, *,
|
|
@@ -6468,6 +8583,15 @@ class GcpIntegrationsPubSubArgs:
|
|
|
6468
8583
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6469
8584
|
|
|
6470
8585
|
|
|
8586
|
+
if not MYPY:
|
|
8587
|
+
class GcpIntegrationsRedisArgsDict(TypedDict):
|
|
8588
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8589
|
+
"""
|
|
8590
|
+
the data polling interval in seconds
|
|
8591
|
+
"""
|
|
8592
|
+
elif False:
|
|
8593
|
+
GcpIntegrationsRedisArgsDict: TypeAlias = Mapping[str, Any]
|
|
8594
|
+
|
|
6471
8595
|
@pulumi.input_type
|
|
6472
8596
|
class GcpIntegrationsRedisArgs:
|
|
6473
8597
|
def __init__(__self__, *,
|
|
@@ -6491,6 +8615,15 @@ class GcpIntegrationsRedisArgs:
|
|
|
6491
8615
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6492
8616
|
|
|
6493
8617
|
|
|
8618
|
+
if not MYPY:
|
|
8619
|
+
class GcpIntegrationsRouterArgsDict(TypedDict):
|
|
8620
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8621
|
+
"""
|
|
8622
|
+
the data polling interval in seconds
|
|
8623
|
+
"""
|
|
8624
|
+
elif False:
|
|
8625
|
+
GcpIntegrationsRouterArgsDict: TypeAlias = Mapping[str, Any]
|
|
8626
|
+
|
|
6494
8627
|
@pulumi.input_type
|
|
6495
8628
|
class GcpIntegrationsRouterArgs:
|
|
6496
8629
|
def __init__(__self__, *,
|
|
@@ -6514,6 +8647,15 @@ class GcpIntegrationsRouterArgs:
|
|
|
6514
8647
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6515
8648
|
|
|
6516
8649
|
|
|
8650
|
+
if not MYPY:
|
|
8651
|
+
class GcpIntegrationsRunArgsDict(TypedDict):
|
|
8652
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8653
|
+
"""
|
|
8654
|
+
the data polling interval in seconds
|
|
8655
|
+
"""
|
|
8656
|
+
elif False:
|
|
8657
|
+
GcpIntegrationsRunArgsDict: TypeAlias = Mapping[str, Any]
|
|
8658
|
+
|
|
6517
8659
|
@pulumi.input_type
|
|
6518
8660
|
class GcpIntegrationsRunArgs:
|
|
6519
8661
|
def __init__(__self__, *,
|
|
@@ -6537,6 +8679,19 @@ class GcpIntegrationsRunArgs:
|
|
|
6537
8679
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6538
8680
|
|
|
6539
8681
|
|
|
8682
|
+
if not MYPY:
|
|
8683
|
+
class GcpIntegrationsSpannerArgsDict(TypedDict):
|
|
8684
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
8685
|
+
"""
|
|
8686
|
+
to fetch tags of the resource
|
|
8687
|
+
"""
|
|
8688
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8689
|
+
"""
|
|
8690
|
+
the data polling interval in seconds
|
|
8691
|
+
"""
|
|
8692
|
+
elif False:
|
|
8693
|
+
GcpIntegrationsSpannerArgsDict: TypeAlias = Mapping[str, Any]
|
|
8694
|
+
|
|
6540
8695
|
@pulumi.input_type
|
|
6541
8696
|
class GcpIntegrationsSpannerArgs:
|
|
6542
8697
|
def __init__(__self__, *,
|
|
@@ -6576,6 +8731,15 @@ class GcpIntegrationsSpannerArgs:
|
|
|
6576
8731
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6577
8732
|
|
|
6578
8733
|
|
|
8734
|
+
if not MYPY:
|
|
8735
|
+
class GcpIntegrationsSqlArgsDict(TypedDict):
|
|
8736
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8737
|
+
"""
|
|
8738
|
+
the data polling interval in seconds
|
|
8739
|
+
"""
|
|
8740
|
+
elif False:
|
|
8741
|
+
GcpIntegrationsSqlArgsDict: TypeAlias = Mapping[str, Any]
|
|
8742
|
+
|
|
6579
8743
|
@pulumi.input_type
|
|
6580
8744
|
class GcpIntegrationsSqlArgs:
|
|
6581
8745
|
def __init__(__self__, *,
|
|
@@ -6599,6 +8763,19 @@ class GcpIntegrationsSqlArgs:
|
|
|
6599
8763
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6600
8764
|
|
|
6601
8765
|
|
|
8766
|
+
if not MYPY:
|
|
8767
|
+
class GcpIntegrationsStorageArgsDict(TypedDict):
|
|
8768
|
+
fetch_tags: NotRequired[pulumi.Input[bool]]
|
|
8769
|
+
"""
|
|
8770
|
+
to fetch tags of the resource
|
|
8771
|
+
"""
|
|
8772
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8773
|
+
"""
|
|
8774
|
+
the data polling interval in seconds
|
|
8775
|
+
"""
|
|
8776
|
+
elif False:
|
|
8777
|
+
GcpIntegrationsStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
8778
|
+
|
|
6602
8779
|
@pulumi.input_type
|
|
6603
8780
|
class GcpIntegrationsStorageArgs:
|
|
6604
8781
|
def __init__(__self__, *,
|
|
@@ -6638,6 +8815,15 @@ class GcpIntegrationsStorageArgs:
|
|
|
6638
8815
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6639
8816
|
|
|
6640
8817
|
|
|
8818
|
+
if not MYPY:
|
|
8819
|
+
class GcpIntegrationsVirtualMachinesArgsDict(TypedDict):
|
|
8820
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8821
|
+
"""
|
|
8822
|
+
the data polling interval in seconds
|
|
8823
|
+
"""
|
|
8824
|
+
elif False:
|
|
8825
|
+
GcpIntegrationsVirtualMachinesArgsDict: TypeAlias = Mapping[str, Any]
|
|
8826
|
+
|
|
6641
8827
|
@pulumi.input_type
|
|
6642
8828
|
class GcpIntegrationsVirtualMachinesArgs:
|
|
6643
8829
|
def __init__(__self__, *,
|
|
@@ -6661,6 +8847,15 @@ class GcpIntegrationsVirtualMachinesArgs:
|
|
|
6661
8847
|
pulumi.set(self, "metrics_polling_interval", value)
|
|
6662
8848
|
|
|
6663
8849
|
|
|
8850
|
+
if not MYPY:
|
|
8851
|
+
class GcpIntegrationsVpcAccessArgsDict(TypedDict):
|
|
8852
|
+
metrics_polling_interval: NotRequired[pulumi.Input[int]]
|
|
8853
|
+
"""
|
|
8854
|
+
the data polling interval in seconds
|
|
8855
|
+
"""
|
|
8856
|
+
elif False:
|
|
8857
|
+
GcpIntegrationsVpcAccessArgsDict: TypeAlias = Mapping[str, Any]
|
|
8858
|
+
|
|
6664
8859
|
@pulumi.input_type
|
|
6665
8860
|
class GcpIntegrationsVpcAccessArgs:
|
|
6666
8861
|
def __init__(__self__, *,
|