@pierskarsenbarg/sdm 0.0.6
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.
- package/LICENSE +202 -0
- package/README.md +56 -0
- package/account.d.ts +73 -0
- package/account.js +60 -0
- package/account.js.map +1 -0
- package/accountAttachment.d.ts +69 -0
- package/accountAttachment.js +66 -0
- package/accountAttachment.js.map +1 -0
- package/accountGrant.d.ts +69 -0
- package/accountGrant.js +66 -0
- package/accountGrant.js.map +1 -0
- package/config/index.d.ts +1 -0
- package/config/index.js +21 -0
- package/config/index.js.map +1 -0
- package/config/vars.d.ts +16 -0
- package/config/vars.js +31 -0
- package/config/vars.js.map +1 -0
- package/getAccount.d.ts +147 -0
- package/getAccount.js +50 -0
- package/getAccount.js.map +1 -0
- package/getAccountAttachment.d.ts +76 -0
- package/getAccountAttachment.js +38 -0
- package/getAccountAttachment.js.map +1 -0
- package/getAccountGrant.d.ts +77 -0
- package/getAccountGrant.js +39 -0
- package/getAccountGrant.js.map +1 -0
- package/getNode.d.ts +123 -0
- package/getNode.js +48 -0
- package/getNode.js.map +1 -0
- package/getRemoteIdentity.d.ts +90 -0
- package/getRemoteIdentity.js +41 -0
- package/getRemoteIdentity.js.map +1 -0
- package/getRemoteIdentityGroup.d.ts +64 -0
- package/getRemoteIdentityGroup.js +37 -0
- package/getRemoteIdentityGroup.js.map +1 -0
- package/getResource.d.ts +107 -0
- package/getResource.js +48 -0
- package/getResource.js.map +1 -0
- package/getRole.d.ts +106 -0
- package/getRole.js +45 -0
- package/getRole.js.map +1 -0
- package/getRoleAttachment.d.ts +79 -0
- package/getRoleAttachment.js +41 -0
- package/getRoleAttachment.js.map +1 -0
- package/getRoleGrant.d.ts +79 -0
- package/getRoleGrant.js +41 -0
- package/getRoleGrant.js.map +1 -0
- package/getSecretStore.d.ts +83 -0
- package/getSecretStore.js +30 -0
- package/getSecretStore.js.map +1 -0
- package/getSshCaPubkey.d.ts +53 -0
- package/getSshCaPubkey.js +35 -0
- package/getSshCaPubkey.js.map +1 -0
- package/index.d.ts +26 -0
- package/index.js +111 -0
- package/index.js.map +1 -0
- package/install-pulumi-plugin.js +26 -0
- package/node.d.ts +70 -0
- package/node.js +60 -0
- package/node.js.map +1 -0
- package/package.json +29 -0
- package/package.json.bak +29 -0
- package/provider.d.ts +55 -0
- package/provider.js +48 -0
- package/provider.js.map +1 -0
- package/remoteIdentity.d.ts +81 -0
- package/remoteIdentity.js +71 -0
- package/remoteIdentity.js.map +1 -0
- package/resource.d.ts +259 -0
- package/resource.js +198 -0
- package/resource.js.map +1 -0
- package/role.d.ts +105 -0
- package/role.js +64 -0
- package/role.js.map +1 -0
- package/roleAttachment.d.ts +69 -0
- package/roleAttachment.js +66 -0
- package/roleAttachment.js.map +1 -0
- package/roleGrant.d.ts +69 -0
- package/roleGrant.js +66 -0
- package/roleGrant.js.map +1 -0
- package/secretStore.d.ts +64 -0
- package/secretStore.js +68 -0
- package/secretStore.js.map +1 -0
- package/types/index.d.ts +3 -0
- package/types/index.js +11 -0
- package/types/index.js.map +1 -0
- package/types/input.d.ts +2690 -0
- package/types/input.js +5 -0
- package/types/input.js.map +1 -0
- package/types/output.d.ts +5596 -0
- package/types/output.js +5 -0
- package/types/output.js.map +1 -0
- package/utilities.d.ts +4 -0
- package/utilities.js +57 -0
- package/utilities.js.map +1 -0
package/types/input.d.ts
ADDED
|
@@ -0,0 +1,2690 @@
|
|
|
1
|
+
import * as pulumi from "@pulumi/pulumi";
|
|
2
|
+
export interface AccountService {
|
|
3
|
+
/**
|
|
4
|
+
* Unique human-readable name of the Service.
|
|
5
|
+
*/
|
|
6
|
+
name: pulumi.Input<string>;
|
|
7
|
+
/**
|
|
8
|
+
* The User's suspended state.
|
|
9
|
+
*/
|
|
10
|
+
suspended?: pulumi.Input<boolean>;
|
|
11
|
+
/**
|
|
12
|
+
* Tags is a map of key, value pairs.
|
|
13
|
+
*/
|
|
14
|
+
tags?: pulumi.Input<{
|
|
15
|
+
[key: string]: pulumi.Input<string>;
|
|
16
|
+
}>;
|
|
17
|
+
token?: pulumi.Input<string>;
|
|
18
|
+
}
|
|
19
|
+
export interface AccountUser {
|
|
20
|
+
/**
|
|
21
|
+
* The User's email address. Must be unique.
|
|
22
|
+
*/
|
|
23
|
+
email: pulumi.Input<string>;
|
|
24
|
+
/**
|
|
25
|
+
* The User's first name.
|
|
26
|
+
*/
|
|
27
|
+
firstName: pulumi.Input<string>;
|
|
28
|
+
/**
|
|
29
|
+
* The User's last name.
|
|
30
|
+
*/
|
|
31
|
+
lastName: pulumi.Input<string>;
|
|
32
|
+
/**
|
|
33
|
+
* The User's suspended state.
|
|
34
|
+
*/
|
|
35
|
+
suspended?: pulumi.Input<boolean>;
|
|
36
|
+
/**
|
|
37
|
+
* Tags is a map of key, value pairs.
|
|
38
|
+
*/
|
|
39
|
+
tags?: pulumi.Input<{
|
|
40
|
+
[key: string]: pulumi.Input<string>;
|
|
41
|
+
}>;
|
|
42
|
+
}
|
|
43
|
+
export interface NodeGateway {
|
|
44
|
+
/**
|
|
45
|
+
* The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".
|
|
46
|
+
*/
|
|
47
|
+
bindAddress?: pulumi.Input<string>;
|
|
48
|
+
/**
|
|
49
|
+
* GatewayFilter can be used to restrict the peering between relays and gateways.
|
|
50
|
+
*/
|
|
51
|
+
gatewayFilter?: pulumi.Input<string>;
|
|
52
|
+
/**
|
|
53
|
+
* The public hostname/port tuple at which the gateway will be accessible to clients.
|
|
54
|
+
*/
|
|
55
|
+
listenAddress: pulumi.Input<string>;
|
|
56
|
+
/**
|
|
57
|
+
* Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
|
|
58
|
+
*/
|
|
59
|
+
name?: pulumi.Input<string>;
|
|
60
|
+
/**
|
|
61
|
+
* Tags is a map of key, value pairs.
|
|
62
|
+
*/
|
|
63
|
+
tags?: pulumi.Input<{
|
|
64
|
+
[key: string]: pulumi.Input<string>;
|
|
65
|
+
}>;
|
|
66
|
+
token?: pulumi.Input<string>;
|
|
67
|
+
}
|
|
68
|
+
export interface NodeRelay {
|
|
69
|
+
/**
|
|
70
|
+
* GatewayFilter can be used to restrict the peering between relays and gateways.
|
|
71
|
+
*/
|
|
72
|
+
gatewayFilter?: pulumi.Input<string>;
|
|
73
|
+
/**
|
|
74
|
+
* Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
|
|
75
|
+
*/
|
|
76
|
+
name?: pulumi.Input<string>;
|
|
77
|
+
/**
|
|
78
|
+
* Tags is a map of key, value pairs.
|
|
79
|
+
*/
|
|
80
|
+
tags?: pulumi.Input<{
|
|
81
|
+
[key: string]: pulumi.Input<string>;
|
|
82
|
+
}>;
|
|
83
|
+
token?: pulumi.Input<string>;
|
|
84
|
+
}
|
|
85
|
+
export interface ResourceAks {
|
|
86
|
+
/**
|
|
87
|
+
* Bind interface
|
|
88
|
+
*/
|
|
89
|
+
bindInterface?: pulumi.Input<string>;
|
|
90
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
91
|
+
clientCertificate?: pulumi.Input<string>;
|
|
92
|
+
clientKey?: pulumi.Input<string>;
|
|
93
|
+
/**
|
|
94
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
95
|
+
*/
|
|
96
|
+
egressFilter?: pulumi.Input<string>;
|
|
97
|
+
/**
|
|
98
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
99
|
+
*/
|
|
100
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
101
|
+
hostname: pulumi.Input<string>;
|
|
102
|
+
/**
|
|
103
|
+
* Unique human-readable name of the Resource.
|
|
104
|
+
*/
|
|
105
|
+
name: pulumi.Input<string>;
|
|
106
|
+
port: pulumi.Input<number>;
|
|
107
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
108
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
109
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
110
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
111
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
112
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
113
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
114
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
115
|
+
/**
|
|
116
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
117
|
+
*/
|
|
118
|
+
secretStoreId?: pulumi.Input<string>;
|
|
119
|
+
/**
|
|
120
|
+
* Tags is a map of key, value pairs.
|
|
121
|
+
*/
|
|
122
|
+
tags?: pulumi.Input<{
|
|
123
|
+
[key: string]: pulumi.Input<string>;
|
|
124
|
+
}>;
|
|
125
|
+
}
|
|
126
|
+
export interface ResourceAksBasicAuth {
|
|
127
|
+
/**
|
|
128
|
+
* Bind interface
|
|
129
|
+
*/
|
|
130
|
+
bindInterface?: pulumi.Input<string>;
|
|
131
|
+
/**
|
|
132
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
133
|
+
*/
|
|
134
|
+
egressFilter?: pulumi.Input<string>;
|
|
135
|
+
/**
|
|
136
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
137
|
+
*/
|
|
138
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
139
|
+
hostname: pulumi.Input<string>;
|
|
140
|
+
/**
|
|
141
|
+
* Unique human-readable name of the Resource.
|
|
142
|
+
*/
|
|
143
|
+
name: pulumi.Input<string>;
|
|
144
|
+
password?: pulumi.Input<string>;
|
|
145
|
+
port: pulumi.Input<number>;
|
|
146
|
+
/**
|
|
147
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
148
|
+
*/
|
|
149
|
+
secretStoreId?: pulumi.Input<string>;
|
|
150
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
151
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
152
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
153
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
154
|
+
/**
|
|
155
|
+
* Tags is a map of key, value pairs.
|
|
156
|
+
*/
|
|
157
|
+
tags?: pulumi.Input<{
|
|
158
|
+
[key: string]: pulumi.Input<string>;
|
|
159
|
+
}>;
|
|
160
|
+
username?: pulumi.Input<string>;
|
|
161
|
+
}
|
|
162
|
+
export interface ResourceAksServiceAccount {
|
|
163
|
+
/**
|
|
164
|
+
* Bind interface
|
|
165
|
+
*/
|
|
166
|
+
bindInterface?: pulumi.Input<string>;
|
|
167
|
+
/**
|
|
168
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
169
|
+
*/
|
|
170
|
+
egressFilter?: pulumi.Input<string>;
|
|
171
|
+
/**
|
|
172
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
173
|
+
*/
|
|
174
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
175
|
+
hostname: pulumi.Input<string>;
|
|
176
|
+
/**
|
|
177
|
+
* Unique human-readable name of the Resource.
|
|
178
|
+
*/
|
|
179
|
+
name: pulumi.Input<string>;
|
|
180
|
+
port: pulumi.Input<number>;
|
|
181
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
182
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
183
|
+
/**
|
|
184
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
185
|
+
*/
|
|
186
|
+
secretStoreId?: pulumi.Input<string>;
|
|
187
|
+
/**
|
|
188
|
+
* * kubernetes_user_impersonation:
|
|
189
|
+
*/
|
|
190
|
+
secretStoreTokenKey?: pulumi.Input<string>;
|
|
191
|
+
secretStoreTokenPath?: pulumi.Input<string>;
|
|
192
|
+
/**
|
|
193
|
+
* Tags is a map of key, value pairs.
|
|
194
|
+
*/
|
|
195
|
+
tags?: pulumi.Input<{
|
|
196
|
+
[key: string]: pulumi.Input<string>;
|
|
197
|
+
}>;
|
|
198
|
+
token?: pulumi.Input<string>;
|
|
199
|
+
}
|
|
200
|
+
export interface ResourceAksServiceAccountUserImpersonation {
|
|
201
|
+
/**
|
|
202
|
+
* Bind interface
|
|
203
|
+
*/
|
|
204
|
+
bindInterface?: pulumi.Input<string>;
|
|
205
|
+
/**
|
|
206
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
207
|
+
*/
|
|
208
|
+
egressFilter?: pulumi.Input<string>;
|
|
209
|
+
/**
|
|
210
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
211
|
+
*/
|
|
212
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
213
|
+
hostname: pulumi.Input<string>;
|
|
214
|
+
/**
|
|
215
|
+
* Unique human-readable name of the Resource.
|
|
216
|
+
*/
|
|
217
|
+
name: pulumi.Input<string>;
|
|
218
|
+
port: pulumi.Input<number>;
|
|
219
|
+
/**
|
|
220
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
221
|
+
*/
|
|
222
|
+
secretStoreId?: pulumi.Input<string>;
|
|
223
|
+
/**
|
|
224
|
+
* * kubernetes_user_impersonation:
|
|
225
|
+
*/
|
|
226
|
+
secretStoreTokenKey?: pulumi.Input<string>;
|
|
227
|
+
secretStoreTokenPath?: pulumi.Input<string>;
|
|
228
|
+
/**
|
|
229
|
+
* Tags is a map of key, value pairs.
|
|
230
|
+
*/
|
|
231
|
+
tags?: pulumi.Input<{
|
|
232
|
+
[key: string]: pulumi.Input<string>;
|
|
233
|
+
}>;
|
|
234
|
+
token?: pulumi.Input<string>;
|
|
235
|
+
}
|
|
236
|
+
export interface ResourceAksUserImpersonation {
|
|
237
|
+
/**
|
|
238
|
+
* Bind interface
|
|
239
|
+
*/
|
|
240
|
+
bindInterface?: pulumi.Input<string>;
|
|
241
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
242
|
+
clientCertificate?: pulumi.Input<string>;
|
|
243
|
+
clientKey?: pulumi.Input<string>;
|
|
244
|
+
/**
|
|
245
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
246
|
+
*/
|
|
247
|
+
egressFilter?: pulumi.Input<string>;
|
|
248
|
+
/**
|
|
249
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
250
|
+
*/
|
|
251
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
252
|
+
hostname: pulumi.Input<string>;
|
|
253
|
+
/**
|
|
254
|
+
* Unique human-readable name of the Resource.
|
|
255
|
+
*/
|
|
256
|
+
name: pulumi.Input<string>;
|
|
257
|
+
port: pulumi.Input<number>;
|
|
258
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
259
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
260
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
261
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
262
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
263
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
264
|
+
/**
|
|
265
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
266
|
+
*/
|
|
267
|
+
secretStoreId?: pulumi.Input<string>;
|
|
268
|
+
/**
|
|
269
|
+
* Tags is a map of key, value pairs.
|
|
270
|
+
*/
|
|
271
|
+
tags?: pulumi.Input<{
|
|
272
|
+
[key: string]: pulumi.Input<string>;
|
|
273
|
+
}>;
|
|
274
|
+
}
|
|
275
|
+
export interface ResourceAmazonEks {
|
|
276
|
+
accessKey?: pulumi.Input<string>;
|
|
277
|
+
/**
|
|
278
|
+
* Bind interface
|
|
279
|
+
*/
|
|
280
|
+
bindInterface?: pulumi.Input<string>;
|
|
281
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
282
|
+
clusterName: pulumi.Input<string>;
|
|
283
|
+
/**
|
|
284
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
285
|
+
*/
|
|
286
|
+
egressFilter?: pulumi.Input<string>;
|
|
287
|
+
endpoint: pulumi.Input<string>;
|
|
288
|
+
/**
|
|
289
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
290
|
+
*/
|
|
291
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
292
|
+
/**
|
|
293
|
+
* Unique human-readable name of the Resource.
|
|
294
|
+
*/
|
|
295
|
+
name: pulumi.Input<string>;
|
|
296
|
+
region: pulumi.Input<string>;
|
|
297
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
298
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
299
|
+
roleArn?: pulumi.Input<string>;
|
|
300
|
+
roleExternalId?: pulumi.Input<string>;
|
|
301
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
302
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
303
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
304
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
305
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
306
|
+
/**
|
|
307
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
308
|
+
*/
|
|
309
|
+
secretStoreId?: pulumi.Input<string>;
|
|
310
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
311
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
312
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
313
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
314
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
315
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
316
|
+
/**
|
|
317
|
+
* Tags is a map of key, value pairs.
|
|
318
|
+
*/
|
|
319
|
+
tags?: pulumi.Input<{
|
|
320
|
+
[key: string]: pulumi.Input<string>;
|
|
321
|
+
}>;
|
|
322
|
+
}
|
|
323
|
+
export interface ResourceAmazonEksUserImpersonation {
|
|
324
|
+
accessKey?: pulumi.Input<string>;
|
|
325
|
+
/**
|
|
326
|
+
* Bind interface
|
|
327
|
+
*/
|
|
328
|
+
bindInterface?: pulumi.Input<string>;
|
|
329
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
330
|
+
clusterName: pulumi.Input<string>;
|
|
331
|
+
/**
|
|
332
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
333
|
+
*/
|
|
334
|
+
egressFilter?: pulumi.Input<string>;
|
|
335
|
+
endpoint: pulumi.Input<string>;
|
|
336
|
+
/**
|
|
337
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
338
|
+
*/
|
|
339
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
340
|
+
/**
|
|
341
|
+
* Unique human-readable name of the Resource.
|
|
342
|
+
*/
|
|
343
|
+
name: pulumi.Input<string>;
|
|
344
|
+
region: pulumi.Input<string>;
|
|
345
|
+
roleArn?: pulumi.Input<string>;
|
|
346
|
+
roleExternalId?: pulumi.Input<string>;
|
|
347
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
348
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
349
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
350
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
351
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
352
|
+
/**
|
|
353
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
354
|
+
*/
|
|
355
|
+
secretStoreId?: pulumi.Input<string>;
|
|
356
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
357
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
358
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
359
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
360
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
361
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
362
|
+
/**
|
|
363
|
+
* Tags is a map of key, value pairs.
|
|
364
|
+
*/
|
|
365
|
+
tags?: pulumi.Input<{
|
|
366
|
+
[key: string]: pulumi.Input<string>;
|
|
367
|
+
}>;
|
|
368
|
+
}
|
|
369
|
+
export interface ResourceAmazonEs {
|
|
370
|
+
accessKey?: pulumi.Input<string>;
|
|
371
|
+
/**
|
|
372
|
+
* Bind interface
|
|
373
|
+
*/
|
|
374
|
+
bindInterface?: pulumi.Input<string>;
|
|
375
|
+
/**
|
|
376
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
377
|
+
*/
|
|
378
|
+
egressFilter?: pulumi.Input<string>;
|
|
379
|
+
endpoint?: pulumi.Input<string>;
|
|
380
|
+
/**
|
|
381
|
+
* Unique human-readable name of the Resource.
|
|
382
|
+
*/
|
|
383
|
+
name: pulumi.Input<string>;
|
|
384
|
+
portOverride?: pulumi.Input<number>;
|
|
385
|
+
region: pulumi.Input<string>;
|
|
386
|
+
roleArn?: pulumi.Input<string>;
|
|
387
|
+
roleExternalId?: pulumi.Input<string>;
|
|
388
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
389
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
390
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
391
|
+
/**
|
|
392
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
393
|
+
*/
|
|
394
|
+
secretStoreId?: pulumi.Input<string>;
|
|
395
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
396
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
397
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
398
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
399
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
400
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
401
|
+
/**
|
|
402
|
+
* Tags is a map of key, value pairs.
|
|
403
|
+
*/
|
|
404
|
+
tags?: pulumi.Input<{
|
|
405
|
+
[key: string]: pulumi.Input<string>;
|
|
406
|
+
}>;
|
|
407
|
+
}
|
|
408
|
+
export interface ResourceAmazonmqAmqp091 {
|
|
409
|
+
/**
|
|
410
|
+
* Bind interface
|
|
411
|
+
*/
|
|
412
|
+
bindInterface?: pulumi.Input<string>;
|
|
413
|
+
/**
|
|
414
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
415
|
+
*/
|
|
416
|
+
egressFilter?: pulumi.Input<string>;
|
|
417
|
+
hostname: pulumi.Input<string>;
|
|
418
|
+
/**
|
|
419
|
+
* Unique human-readable name of the Resource.
|
|
420
|
+
*/
|
|
421
|
+
name: pulumi.Input<string>;
|
|
422
|
+
password?: pulumi.Input<string>;
|
|
423
|
+
port?: pulumi.Input<number>;
|
|
424
|
+
portOverride?: pulumi.Input<number>;
|
|
425
|
+
/**
|
|
426
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
427
|
+
*/
|
|
428
|
+
secretStoreId?: pulumi.Input<string>;
|
|
429
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
430
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
431
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
432
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
433
|
+
/**
|
|
434
|
+
* Tags is a map of key, value pairs.
|
|
435
|
+
*/
|
|
436
|
+
tags?: pulumi.Input<{
|
|
437
|
+
[key: string]: pulumi.Input<string>;
|
|
438
|
+
}>;
|
|
439
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
440
|
+
username?: pulumi.Input<string>;
|
|
441
|
+
}
|
|
442
|
+
export interface ResourceAthena {
|
|
443
|
+
accessKey?: pulumi.Input<string>;
|
|
444
|
+
/**
|
|
445
|
+
* Bind interface
|
|
446
|
+
*/
|
|
447
|
+
bindInterface?: pulumi.Input<string>;
|
|
448
|
+
/**
|
|
449
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
450
|
+
*/
|
|
451
|
+
egressFilter?: pulumi.Input<string>;
|
|
452
|
+
/**
|
|
453
|
+
* Unique human-readable name of the Resource.
|
|
454
|
+
*/
|
|
455
|
+
name: pulumi.Input<string>;
|
|
456
|
+
output: pulumi.Input<string>;
|
|
457
|
+
portOverride?: pulumi.Input<number>;
|
|
458
|
+
region?: pulumi.Input<string>;
|
|
459
|
+
roleArn?: pulumi.Input<string>;
|
|
460
|
+
roleExternalId?: pulumi.Input<string>;
|
|
461
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
462
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
463
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
464
|
+
/**
|
|
465
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
466
|
+
*/
|
|
467
|
+
secretStoreId?: pulumi.Input<string>;
|
|
468
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
469
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
470
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
471
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
472
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
473
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
474
|
+
/**
|
|
475
|
+
* Tags is a map of key, value pairs.
|
|
476
|
+
*/
|
|
477
|
+
tags?: pulumi.Input<{
|
|
478
|
+
[key: string]: pulumi.Input<string>;
|
|
479
|
+
}>;
|
|
480
|
+
}
|
|
481
|
+
export interface ResourceAuroraMysql {
|
|
482
|
+
/**
|
|
483
|
+
* Bind interface
|
|
484
|
+
*/
|
|
485
|
+
bindInterface?: pulumi.Input<string>;
|
|
486
|
+
database: pulumi.Input<string>;
|
|
487
|
+
/**
|
|
488
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
489
|
+
*/
|
|
490
|
+
egressFilter?: pulumi.Input<string>;
|
|
491
|
+
hostname: pulumi.Input<string>;
|
|
492
|
+
/**
|
|
493
|
+
* Unique human-readable name of the Resource.
|
|
494
|
+
*/
|
|
495
|
+
name: pulumi.Input<string>;
|
|
496
|
+
password?: pulumi.Input<string>;
|
|
497
|
+
port?: pulumi.Input<number>;
|
|
498
|
+
portOverride?: pulumi.Input<number>;
|
|
499
|
+
/**
|
|
500
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
501
|
+
*/
|
|
502
|
+
secretStoreId?: pulumi.Input<string>;
|
|
503
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
504
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
505
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
506
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
507
|
+
/**
|
|
508
|
+
* Tags is a map of key, value pairs.
|
|
509
|
+
*/
|
|
510
|
+
tags?: pulumi.Input<{
|
|
511
|
+
[key: string]: pulumi.Input<string>;
|
|
512
|
+
}>;
|
|
513
|
+
username?: pulumi.Input<string>;
|
|
514
|
+
}
|
|
515
|
+
export interface ResourceAuroraPostgres {
|
|
516
|
+
/**
|
|
517
|
+
* Bind interface
|
|
518
|
+
*/
|
|
519
|
+
bindInterface?: pulumi.Input<string>;
|
|
520
|
+
database: pulumi.Input<string>;
|
|
521
|
+
/**
|
|
522
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
523
|
+
*/
|
|
524
|
+
egressFilter?: pulumi.Input<string>;
|
|
525
|
+
hostname: pulumi.Input<string>;
|
|
526
|
+
/**
|
|
527
|
+
* Unique human-readable name of the Resource.
|
|
528
|
+
*/
|
|
529
|
+
name: pulumi.Input<string>;
|
|
530
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
531
|
+
password?: pulumi.Input<string>;
|
|
532
|
+
port?: pulumi.Input<number>;
|
|
533
|
+
portOverride?: pulumi.Input<number>;
|
|
534
|
+
/**
|
|
535
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
536
|
+
*/
|
|
537
|
+
secretStoreId?: pulumi.Input<string>;
|
|
538
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
539
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
540
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
541
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
542
|
+
/**
|
|
543
|
+
* Tags is a map of key, value pairs.
|
|
544
|
+
*/
|
|
545
|
+
tags?: pulumi.Input<{
|
|
546
|
+
[key: string]: pulumi.Input<string>;
|
|
547
|
+
}>;
|
|
548
|
+
username?: pulumi.Input<string>;
|
|
549
|
+
}
|
|
550
|
+
export interface ResourceAws {
|
|
551
|
+
accessKey?: pulumi.Input<string>;
|
|
552
|
+
/**
|
|
553
|
+
* Bind interface
|
|
554
|
+
*/
|
|
555
|
+
bindInterface?: pulumi.Input<string>;
|
|
556
|
+
/**
|
|
557
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
558
|
+
*/
|
|
559
|
+
egressFilter?: pulumi.Input<string>;
|
|
560
|
+
healthcheckRegion: pulumi.Input<string>;
|
|
561
|
+
/**
|
|
562
|
+
* Unique human-readable name of the Resource.
|
|
563
|
+
*/
|
|
564
|
+
name: pulumi.Input<string>;
|
|
565
|
+
roleArn?: pulumi.Input<string>;
|
|
566
|
+
roleExternalId?: pulumi.Input<string>;
|
|
567
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
568
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
569
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
570
|
+
/**
|
|
571
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
572
|
+
*/
|
|
573
|
+
secretStoreId?: pulumi.Input<string>;
|
|
574
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
575
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
576
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
577
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
578
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
579
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
580
|
+
/**
|
|
581
|
+
* Tags is a map of key, value pairs.
|
|
582
|
+
*/
|
|
583
|
+
tags?: pulumi.Input<{
|
|
584
|
+
[key: string]: pulumi.Input<string>;
|
|
585
|
+
}>;
|
|
586
|
+
}
|
|
587
|
+
export interface ResourceAzure {
|
|
588
|
+
appId?: pulumi.Input<string>;
|
|
589
|
+
/**
|
|
590
|
+
* Bind interface
|
|
591
|
+
*/
|
|
592
|
+
bindInterface?: pulumi.Input<string>;
|
|
593
|
+
/**
|
|
594
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
595
|
+
*/
|
|
596
|
+
egressFilter?: pulumi.Input<string>;
|
|
597
|
+
/**
|
|
598
|
+
* Unique human-readable name of the Resource.
|
|
599
|
+
*/
|
|
600
|
+
name: pulumi.Input<string>;
|
|
601
|
+
password?: pulumi.Input<string>;
|
|
602
|
+
secretStoreAppIdKey?: pulumi.Input<string>;
|
|
603
|
+
secretStoreAppIdPath?: pulumi.Input<string>;
|
|
604
|
+
/**
|
|
605
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
606
|
+
*/
|
|
607
|
+
secretStoreId?: pulumi.Input<string>;
|
|
608
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
609
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
610
|
+
/**
|
|
611
|
+
* * azure_postgres:
|
|
612
|
+
*/
|
|
613
|
+
secretStoreTenantIdKey?: pulumi.Input<string>;
|
|
614
|
+
secretStoreTenantIdPath?: pulumi.Input<string>;
|
|
615
|
+
/**
|
|
616
|
+
* Tags is a map of key, value pairs.
|
|
617
|
+
*/
|
|
618
|
+
tags?: pulumi.Input<{
|
|
619
|
+
[key: string]: pulumi.Input<string>;
|
|
620
|
+
}>;
|
|
621
|
+
tenantId?: pulumi.Input<string>;
|
|
622
|
+
}
|
|
623
|
+
export interface ResourceAzureCertificate {
|
|
624
|
+
appId?: pulumi.Input<string>;
|
|
625
|
+
/**
|
|
626
|
+
* Bind interface
|
|
627
|
+
*/
|
|
628
|
+
bindInterface?: pulumi.Input<string>;
|
|
629
|
+
clientCertificate?: pulumi.Input<string>;
|
|
630
|
+
/**
|
|
631
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
632
|
+
*/
|
|
633
|
+
egressFilter?: pulumi.Input<string>;
|
|
634
|
+
/**
|
|
635
|
+
* Unique human-readable name of the Resource.
|
|
636
|
+
*/
|
|
637
|
+
name: pulumi.Input<string>;
|
|
638
|
+
secretStoreAppIdKey?: pulumi.Input<string>;
|
|
639
|
+
secretStoreAppIdPath?: pulumi.Input<string>;
|
|
640
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
641
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
642
|
+
/**
|
|
643
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
644
|
+
*/
|
|
645
|
+
secretStoreId?: pulumi.Input<string>;
|
|
646
|
+
/**
|
|
647
|
+
* * azure_postgres:
|
|
648
|
+
*/
|
|
649
|
+
secretStoreTenantIdKey?: pulumi.Input<string>;
|
|
650
|
+
secretStoreTenantIdPath?: pulumi.Input<string>;
|
|
651
|
+
/**
|
|
652
|
+
* Tags is a map of key, value pairs.
|
|
653
|
+
*/
|
|
654
|
+
tags?: pulumi.Input<{
|
|
655
|
+
[key: string]: pulumi.Input<string>;
|
|
656
|
+
}>;
|
|
657
|
+
tenantId?: pulumi.Input<string>;
|
|
658
|
+
}
|
|
659
|
+
export interface ResourceAzurePostgres {
|
|
660
|
+
/**
|
|
661
|
+
* Bind interface
|
|
662
|
+
*/
|
|
663
|
+
bindInterface?: pulumi.Input<string>;
|
|
664
|
+
database: pulumi.Input<string>;
|
|
665
|
+
/**
|
|
666
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
667
|
+
*/
|
|
668
|
+
egressFilter?: pulumi.Input<string>;
|
|
669
|
+
hostname: pulumi.Input<string>;
|
|
670
|
+
/**
|
|
671
|
+
* Unique human-readable name of the Resource.
|
|
672
|
+
*/
|
|
673
|
+
name: pulumi.Input<string>;
|
|
674
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
675
|
+
password?: pulumi.Input<string>;
|
|
676
|
+
port?: pulumi.Input<number>;
|
|
677
|
+
portOverride?: pulumi.Input<number>;
|
|
678
|
+
/**
|
|
679
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
680
|
+
*/
|
|
681
|
+
secretStoreId?: pulumi.Input<string>;
|
|
682
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
683
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
684
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
685
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
686
|
+
/**
|
|
687
|
+
* Tags is a map of key, value pairs.
|
|
688
|
+
*/
|
|
689
|
+
tags?: pulumi.Input<{
|
|
690
|
+
[key: string]: pulumi.Input<string>;
|
|
691
|
+
}>;
|
|
692
|
+
username?: pulumi.Input<string>;
|
|
693
|
+
}
|
|
694
|
+
export interface ResourceBigQuery {
|
|
695
|
+
/**
|
|
696
|
+
* Bind interface
|
|
697
|
+
*/
|
|
698
|
+
bindInterface?: pulumi.Input<string>;
|
|
699
|
+
/**
|
|
700
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
701
|
+
*/
|
|
702
|
+
egressFilter?: pulumi.Input<string>;
|
|
703
|
+
endpoint: pulumi.Input<string>;
|
|
704
|
+
/**
|
|
705
|
+
* Unique human-readable name of the Resource.
|
|
706
|
+
*/
|
|
707
|
+
name: pulumi.Input<string>;
|
|
708
|
+
portOverride?: pulumi.Input<number>;
|
|
709
|
+
privateKey?: pulumi.Input<string>;
|
|
710
|
+
project: pulumi.Input<string>;
|
|
711
|
+
/**
|
|
712
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
713
|
+
*/
|
|
714
|
+
secretStoreId?: pulumi.Input<string>;
|
|
715
|
+
secretStorePrivateKeyKey?: pulumi.Input<string>;
|
|
716
|
+
secretStorePrivateKeyPath?: pulumi.Input<string>;
|
|
717
|
+
/**
|
|
718
|
+
* Tags is a map of key, value pairs.
|
|
719
|
+
*/
|
|
720
|
+
tags?: pulumi.Input<{
|
|
721
|
+
[key: string]: pulumi.Input<string>;
|
|
722
|
+
}>;
|
|
723
|
+
username?: pulumi.Input<string>;
|
|
724
|
+
}
|
|
725
|
+
export interface ResourceCassandra {
|
|
726
|
+
/**
|
|
727
|
+
* Bind interface
|
|
728
|
+
*/
|
|
729
|
+
bindInterface?: pulumi.Input<string>;
|
|
730
|
+
/**
|
|
731
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
732
|
+
*/
|
|
733
|
+
egressFilter?: pulumi.Input<string>;
|
|
734
|
+
hostname: pulumi.Input<string>;
|
|
735
|
+
/**
|
|
736
|
+
* Unique human-readable name of the Resource.
|
|
737
|
+
*/
|
|
738
|
+
name: pulumi.Input<string>;
|
|
739
|
+
password?: pulumi.Input<string>;
|
|
740
|
+
port?: pulumi.Input<number>;
|
|
741
|
+
portOverride?: pulumi.Input<number>;
|
|
742
|
+
/**
|
|
743
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
744
|
+
*/
|
|
745
|
+
secretStoreId?: pulumi.Input<string>;
|
|
746
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
747
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
748
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
749
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
750
|
+
/**
|
|
751
|
+
* Tags is a map of key, value pairs.
|
|
752
|
+
*/
|
|
753
|
+
tags?: pulumi.Input<{
|
|
754
|
+
[key: string]: pulumi.Input<string>;
|
|
755
|
+
}>;
|
|
756
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
757
|
+
username?: pulumi.Input<string>;
|
|
758
|
+
}
|
|
759
|
+
export interface ResourceCitus {
|
|
760
|
+
/**
|
|
761
|
+
* Bind interface
|
|
762
|
+
*/
|
|
763
|
+
bindInterface?: pulumi.Input<string>;
|
|
764
|
+
database: pulumi.Input<string>;
|
|
765
|
+
/**
|
|
766
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
767
|
+
*/
|
|
768
|
+
egressFilter?: pulumi.Input<string>;
|
|
769
|
+
hostname: pulumi.Input<string>;
|
|
770
|
+
/**
|
|
771
|
+
* Unique human-readable name of the Resource.
|
|
772
|
+
*/
|
|
773
|
+
name: pulumi.Input<string>;
|
|
774
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
775
|
+
password?: pulumi.Input<string>;
|
|
776
|
+
port?: pulumi.Input<number>;
|
|
777
|
+
portOverride?: pulumi.Input<number>;
|
|
778
|
+
/**
|
|
779
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
780
|
+
*/
|
|
781
|
+
secretStoreId?: pulumi.Input<string>;
|
|
782
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
783
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
784
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
785
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
786
|
+
/**
|
|
787
|
+
* Tags is a map of key, value pairs.
|
|
788
|
+
*/
|
|
789
|
+
tags?: pulumi.Input<{
|
|
790
|
+
[key: string]: pulumi.Input<string>;
|
|
791
|
+
}>;
|
|
792
|
+
username?: pulumi.Input<string>;
|
|
793
|
+
}
|
|
794
|
+
export interface ResourceClustrix {
|
|
795
|
+
/**
|
|
796
|
+
* Bind interface
|
|
797
|
+
*/
|
|
798
|
+
bindInterface?: pulumi.Input<string>;
|
|
799
|
+
database: pulumi.Input<string>;
|
|
800
|
+
/**
|
|
801
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
802
|
+
*/
|
|
803
|
+
egressFilter?: pulumi.Input<string>;
|
|
804
|
+
hostname: pulumi.Input<string>;
|
|
805
|
+
/**
|
|
806
|
+
* Unique human-readable name of the Resource.
|
|
807
|
+
*/
|
|
808
|
+
name: pulumi.Input<string>;
|
|
809
|
+
password?: pulumi.Input<string>;
|
|
810
|
+
port?: pulumi.Input<number>;
|
|
811
|
+
portOverride?: pulumi.Input<number>;
|
|
812
|
+
/**
|
|
813
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
814
|
+
*/
|
|
815
|
+
secretStoreId?: pulumi.Input<string>;
|
|
816
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
817
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
818
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
819
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
820
|
+
/**
|
|
821
|
+
* Tags is a map of key, value pairs.
|
|
822
|
+
*/
|
|
823
|
+
tags?: pulumi.Input<{
|
|
824
|
+
[key: string]: pulumi.Input<string>;
|
|
825
|
+
}>;
|
|
826
|
+
username?: pulumi.Input<string>;
|
|
827
|
+
}
|
|
828
|
+
export interface ResourceCockroach {
|
|
829
|
+
/**
|
|
830
|
+
* Bind interface
|
|
831
|
+
*/
|
|
832
|
+
bindInterface?: pulumi.Input<string>;
|
|
833
|
+
database: pulumi.Input<string>;
|
|
834
|
+
/**
|
|
835
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
836
|
+
*/
|
|
837
|
+
egressFilter?: pulumi.Input<string>;
|
|
838
|
+
hostname: pulumi.Input<string>;
|
|
839
|
+
/**
|
|
840
|
+
* Unique human-readable name of the Resource.
|
|
841
|
+
*/
|
|
842
|
+
name: pulumi.Input<string>;
|
|
843
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
844
|
+
password?: pulumi.Input<string>;
|
|
845
|
+
port?: pulumi.Input<number>;
|
|
846
|
+
portOverride?: pulumi.Input<number>;
|
|
847
|
+
/**
|
|
848
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
849
|
+
*/
|
|
850
|
+
secretStoreId?: pulumi.Input<string>;
|
|
851
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
852
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
853
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
854
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
855
|
+
/**
|
|
856
|
+
* Tags is a map of key, value pairs.
|
|
857
|
+
*/
|
|
858
|
+
tags?: pulumi.Input<{
|
|
859
|
+
[key: string]: pulumi.Input<string>;
|
|
860
|
+
}>;
|
|
861
|
+
username?: pulumi.Input<string>;
|
|
862
|
+
}
|
|
863
|
+
export interface ResourceDb2I {
|
|
864
|
+
/**
|
|
865
|
+
* Bind interface
|
|
866
|
+
*/
|
|
867
|
+
bindInterface?: pulumi.Input<string>;
|
|
868
|
+
/**
|
|
869
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
870
|
+
*/
|
|
871
|
+
egressFilter?: pulumi.Input<string>;
|
|
872
|
+
hostname: pulumi.Input<string>;
|
|
873
|
+
/**
|
|
874
|
+
* Unique human-readable name of the Resource.
|
|
875
|
+
*/
|
|
876
|
+
name: pulumi.Input<string>;
|
|
877
|
+
password?: pulumi.Input<string>;
|
|
878
|
+
port?: pulumi.Input<number>;
|
|
879
|
+
portOverride?: pulumi.Input<number>;
|
|
880
|
+
/**
|
|
881
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
882
|
+
*/
|
|
883
|
+
secretStoreId?: pulumi.Input<string>;
|
|
884
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
885
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
886
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
887
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
888
|
+
/**
|
|
889
|
+
* Tags is a map of key, value pairs.
|
|
890
|
+
*/
|
|
891
|
+
tags?: pulumi.Input<{
|
|
892
|
+
[key: string]: pulumi.Input<string>;
|
|
893
|
+
}>;
|
|
894
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
895
|
+
username?: pulumi.Input<string>;
|
|
896
|
+
}
|
|
897
|
+
export interface ResourceDb2Luw {
|
|
898
|
+
/**
|
|
899
|
+
* Bind interface
|
|
900
|
+
*/
|
|
901
|
+
bindInterface?: pulumi.Input<string>;
|
|
902
|
+
database: pulumi.Input<string>;
|
|
903
|
+
/**
|
|
904
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
905
|
+
*/
|
|
906
|
+
egressFilter?: pulumi.Input<string>;
|
|
907
|
+
hostname: pulumi.Input<string>;
|
|
908
|
+
/**
|
|
909
|
+
* Unique human-readable name of the Resource.
|
|
910
|
+
*/
|
|
911
|
+
name: pulumi.Input<string>;
|
|
912
|
+
password?: pulumi.Input<string>;
|
|
913
|
+
port?: pulumi.Input<number>;
|
|
914
|
+
portOverride?: pulumi.Input<number>;
|
|
915
|
+
/**
|
|
916
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
917
|
+
*/
|
|
918
|
+
secretStoreId?: pulumi.Input<string>;
|
|
919
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
920
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
921
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
922
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
923
|
+
/**
|
|
924
|
+
* Tags is a map of key, value pairs.
|
|
925
|
+
*/
|
|
926
|
+
tags?: pulumi.Input<{
|
|
927
|
+
[key: string]: pulumi.Input<string>;
|
|
928
|
+
}>;
|
|
929
|
+
username?: pulumi.Input<string>;
|
|
930
|
+
}
|
|
931
|
+
export interface ResourceDocumentDbHost {
|
|
932
|
+
authDatabase: pulumi.Input<string>;
|
|
933
|
+
/**
|
|
934
|
+
* Bind interface
|
|
935
|
+
*/
|
|
936
|
+
bindInterface?: pulumi.Input<string>;
|
|
937
|
+
/**
|
|
938
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
939
|
+
*/
|
|
940
|
+
egressFilter?: pulumi.Input<string>;
|
|
941
|
+
hostname: pulumi.Input<string>;
|
|
942
|
+
/**
|
|
943
|
+
* Unique human-readable name of the Resource.
|
|
944
|
+
*/
|
|
945
|
+
name: pulumi.Input<string>;
|
|
946
|
+
password?: pulumi.Input<string>;
|
|
947
|
+
port?: pulumi.Input<number>;
|
|
948
|
+
portOverride?: pulumi.Input<number>;
|
|
949
|
+
/**
|
|
950
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
951
|
+
*/
|
|
952
|
+
secretStoreId?: pulumi.Input<string>;
|
|
953
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
954
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
955
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
956
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
957
|
+
/**
|
|
958
|
+
* Tags is a map of key, value pairs.
|
|
959
|
+
*/
|
|
960
|
+
tags?: pulumi.Input<{
|
|
961
|
+
[key: string]: pulumi.Input<string>;
|
|
962
|
+
}>;
|
|
963
|
+
username?: pulumi.Input<string>;
|
|
964
|
+
}
|
|
965
|
+
export interface ResourceDocumentDbReplicaSet {
|
|
966
|
+
authDatabase: pulumi.Input<string>;
|
|
967
|
+
/**
|
|
968
|
+
* Bind interface
|
|
969
|
+
*/
|
|
970
|
+
bindInterface?: pulumi.Input<string>;
|
|
971
|
+
connectToReplica?: pulumi.Input<boolean>;
|
|
972
|
+
/**
|
|
973
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
974
|
+
*/
|
|
975
|
+
egressFilter?: pulumi.Input<string>;
|
|
976
|
+
hostname: pulumi.Input<string>;
|
|
977
|
+
/**
|
|
978
|
+
* Unique human-readable name of the Resource.
|
|
979
|
+
*/
|
|
980
|
+
name: pulumi.Input<string>;
|
|
981
|
+
password?: pulumi.Input<string>;
|
|
982
|
+
portOverride?: pulumi.Input<number>;
|
|
983
|
+
replicaSet: pulumi.Input<string>;
|
|
984
|
+
/**
|
|
985
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
986
|
+
*/
|
|
987
|
+
secretStoreId?: pulumi.Input<string>;
|
|
988
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
989
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
990
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
991
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
992
|
+
/**
|
|
993
|
+
* Tags is a map of key, value pairs.
|
|
994
|
+
*/
|
|
995
|
+
tags?: pulumi.Input<{
|
|
996
|
+
[key: string]: pulumi.Input<string>;
|
|
997
|
+
}>;
|
|
998
|
+
username?: pulumi.Input<string>;
|
|
999
|
+
}
|
|
1000
|
+
export interface ResourceDruid {
|
|
1001
|
+
/**
|
|
1002
|
+
* Bind interface
|
|
1003
|
+
*/
|
|
1004
|
+
bindInterface?: pulumi.Input<string>;
|
|
1005
|
+
/**
|
|
1006
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1007
|
+
*/
|
|
1008
|
+
egressFilter?: pulumi.Input<string>;
|
|
1009
|
+
hostname: pulumi.Input<string>;
|
|
1010
|
+
/**
|
|
1011
|
+
* Unique human-readable name of the Resource.
|
|
1012
|
+
*/
|
|
1013
|
+
name: pulumi.Input<string>;
|
|
1014
|
+
password?: pulumi.Input<string>;
|
|
1015
|
+
port?: pulumi.Input<number>;
|
|
1016
|
+
portOverride?: pulumi.Input<number>;
|
|
1017
|
+
/**
|
|
1018
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1019
|
+
*/
|
|
1020
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1021
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1022
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1023
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1024
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1025
|
+
/**
|
|
1026
|
+
* Tags is a map of key, value pairs.
|
|
1027
|
+
*/
|
|
1028
|
+
tags?: pulumi.Input<{
|
|
1029
|
+
[key: string]: pulumi.Input<string>;
|
|
1030
|
+
}>;
|
|
1031
|
+
username?: pulumi.Input<string>;
|
|
1032
|
+
}
|
|
1033
|
+
export interface ResourceDynamoDb {
|
|
1034
|
+
accessKey?: pulumi.Input<string>;
|
|
1035
|
+
/**
|
|
1036
|
+
* Bind interface
|
|
1037
|
+
*/
|
|
1038
|
+
bindInterface?: pulumi.Input<string>;
|
|
1039
|
+
/**
|
|
1040
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1041
|
+
*/
|
|
1042
|
+
egressFilter?: pulumi.Input<string>;
|
|
1043
|
+
endpoint: pulumi.Input<string>;
|
|
1044
|
+
/**
|
|
1045
|
+
* Unique human-readable name of the Resource.
|
|
1046
|
+
*/
|
|
1047
|
+
name: pulumi.Input<string>;
|
|
1048
|
+
portOverride?: pulumi.Input<number>;
|
|
1049
|
+
region: pulumi.Input<string>;
|
|
1050
|
+
roleArn?: pulumi.Input<string>;
|
|
1051
|
+
roleExternalId?: pulumi.Input<string>;
|
|
1052
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
1053
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
1054
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
1055
|
+
/**
|
|
1056
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1057
|
+
*/
|
|
1058
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1059
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
1060
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
1061
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
1062
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
1063
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
1064
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
1065
|
+
/**
|
|
1066
|
+
* Tags is a map of key, value pairs.
|
|
1067
|
+
*/
|
|
1068
|
+
tags?: pulumi.Input<{
|
|
1069
|
+
[key: string]: pulumi.Input<string>;
|
|
1070
|
+
}>;
|
|
1071
|
+
}
|
|
1072
|
+
export interface ResourceElastic {
|
|
1073
|
+
/**
|
|
1074
|
+
* Bind interface
|
|
1075
|
+
*/
|
|
1076
|
+
bindInterface?: pulumi.Input<string>;
|
|
1077
|
+
/**
|
|
1078
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1079
|
+
*/
|
|
1080
|
+
egressFilter?: pulumi.Input<string>;
|
|
1081
|
+
hostname: pulumi.Input<string>;
|
|
1082
|
+
/**
|
|
1083
|
+
* Unique human-readable name of the Resource.
|
|
1084
|
+
*/
|
|
1085
|
+
name: pulumi.Input<string>;
|
|
1086
|
+
password?: pulumi.Input<string>;
|
|
1087
|
+
port?: pulumi.Input<number>;
|
|
1088
|
+
portOverride?: pulumi.Input<number>;
|
|
1089
|
+
/**
|
|
1090
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1091
|
+
*/
|
|
1092
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1093
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1094
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1095
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1096
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1097
|
+
/**
|
|
1098
|
+
* Tags is a map of key, value pairs.
|
|
1099
|
+
*/
|
|
1100
|
+
tags?: pulumi.Input<{
|
|
1101
|
+
[key: string]: pulumi.Input<string>;
|
|
1102
|
+
}>;
|
|
1103
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1104
|
+
username?: pulumi.Input<string>;
|
|
1105
|
+
}
|
|
1106
|
+
export interface ResourceElasticacheRedis {
|
|
1107
|
+
/**
|
|
1108
|
+
* Bind interface
|
|
1109
|
+
*/
|
|
1110
|
+
bindInterface?: pulumi.Input<string>;
|
|
1111
|
+
/**
|
|
1112
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1113
|
+
*/
|
|
1114
|
+
egressFilter?: pulumi.Input<string>;
|
|
1115
|
+
hostname: pulumi.Input<string>;
|
|
1116
|
+
/**
|
|
1117
|
+
* Unique human-readable name of the Resource.
|
|
1118
|
+
*/
|
|
1119
|
+
name: pulumi.Input<string>;
|
|
1120
|
+
password?: pulumi.Input<string>;
|
|
1121
|
+
port?: pulumi.Input<number>;
|
|
1122
|
+
portOverride?: pulumi.Input<number>;
|
|
1123
|
+
/**
|
|
1124
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1125
|
+
*/
|
|
1126
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1127
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1128
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1129
|
+
/**
|
|
1130
|
+
* Tags is a map of key, value pairs.
|
|
1131
|
+
*/
|
|
1132
|
+
tags?: pulumi.Input<{
|
|
1133
|
+
[key: string]: pulumi.Input<string>;
|
|
1134
|
+
}>;
|
|
1135
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1136
|
+
}
|
|
1137
|
+
export interface ResourceGcp {
|
|
1138
|
+
/**
|
|
1139
|
+
* Bind interface
|
|
1140
|
+
*/
|
|
1141
|
+
bindInterface?: pulumi.Input<string>;
|
|
1142
|
+
/**
|
|
1143
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1144
|
+
*/
|
|
1145
|
+
egressFilter?: pulumi.Input<string>;
|
|
1146
|
+
keyfile?: pulumi.Input<string>;
|
|
1147
|
+
/**
|
|
1148
|
+
* Unique human-readable name of the Resource.
|
|
1149
|
+
*/
|
|
1150
|
+
name: pulumi.Input<string>;
|
|
1151
|
+
scopes: pulumi.Input<string>;
|
|
1152
|
+
/**
|
|
1153
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1154
|
+
*/
|
|
1155
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1156
|
+
secretStoreKeyfileKey?: pulumi.Input<string>;
|
|
1157
|
+
secretStoreKeyfilePath?: pulumi.Input<string>;
|
|
1158
|
+
/**
|
|
1159
|
+
* Tags is a map of key, value pairs.
|
|
1160
|
+
*/
|
|
1161
|
+
tags?: pulumi.Input<{
|
|
1162
|
+
[key: string]: pulumi.Input<string>;
|
|
1163
|
+
}>;
|
|
1164
|
+
}
|
|
1165
|
+
export interface ResourceGoogleGke {
|
|
1166
|
+
/**
|
|
1167
|
+
* Bind interface
|
|
1168
|
+
*/
|
|
1169
|
+
bindInterface?: pulumi.Input<string>;
|
|
1170
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1171
|
+
/**
|
|
1172
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1173
|
+
*/
|
|
1174
|
+
egressFilter?: pulumi.Input<string>;
|
|
1175
|
+
endpoint: pulumi.Input<string>;
|
|
1176
|
+
/**
|
|
1177
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1178
|
+
*/
|
|
1179
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1180
|
+
/**
|
|
1181
|
+
* Unique human-readable name of the Resource.
|
|
1182
|
+
*/
|
|
1183
|
+
name: pulumi.Input<string>;
|
|
1184
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
1185
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
1186
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1187
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1188
|
+
/**
|
|
1189
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1190
|
+
*/
|
|
1191
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1192
|
+
secretStoreServiceAccountKeyKey?: pulumi.Input<string>;
|
|
1193
|
+
secretStoreServiceAccountKeyPath?: pulumi.Input<string>;
|
|
1194
|
+
serviceAccountKey?: pulumi.Input<string>;
|
|
1195
|
+
/**
|
|
1196
|
+
* Tags is a map of key, value pairs.
|
|
1197
|
+
*/
|
|
1198
|
+
tags?: pulumi.Input<{
|
|
1199
|
+
[key: string]: pulumi.Input<string>;
|
|
1200
|
+
}>;
|
|
1201
|
+
}
|
|
1202
|
+
export interface ResourceGoogleGkeUserImpersonation {
|
|
1203
|
+
/**
|
|
1204
|
+
* Bind interface
|
|
1205
|
+
*/
|
|
1206
|
+
bindInterface?: pulumi.Input<string>;
|
|
1207
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1208
|
+
/**
|
|
1209
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1210
|
+
*/
|
|
1211
|
+
egressFilter?: pulumi.Input<string>;
|
|
1212
|
+
endpoint: pulumi.Input<string>;
|
|
1213
|
+
/**
|
|
1214
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1215
|
+
*/
|
|
1216
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1217
|
+
/**
|
|
1218
|
+
* Unique human-readable name of the Resource.
|
|
1219
|
+
*/
|
|
1220
|
+
name: pulumi.Input<string>;
|
|
1221
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1222
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1223
|
+
/**
|
|
1224
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1225
|
+
*/
|
|
1226
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1227
|
+
secretStoreServiceAccountKeyKey?: pulumi.Input<string>;
|
|
1228
|
+
secretStoreServiceAccountKeyPath?: pulumi.Input<string>;
|
|
1229
|
+
serviceAccountKey?: pulumi.Input<string>;
|
|
1230
|
+
/**
|
|
1231
|
+
* Tags is a map of key, value pairs.
|
|
1232
|
+
*/
|
|
1233
|
+
tags?: pulumi.Input<{
|
|
1234
|
+
[key: string]: pulumi.Input<string>;
|
|
1235
|
+
}>;
|
|
1236
|
+
}
|
|
1237
|
+
export interface ResourceGreenplum {
|
|
1238
|
+
/**
|
|
1239
|
+
* Bind interface
|
|
1240
|
+
*/
|
|
1241
|
+
bindInterface?: pulumi.Input<string>;
|
|
1242
|
+
database: pulumi.Input<string>;
|
|
1243
|
+
/**
|
|
1244
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1245
|
+
*/
|
|
1246
|
+
egressFilter?: pulumi.Input<string>;
|
|
1247
|
+
hostname: pulumi.Input<string>;
|
|
1248
|
+
/**
|
|
1249
|
+
* Unique human-readable name of the Resource.
|
|
1250
|
+
*/
|
|
1251
|
+
name: pulumi.Input<string>;
|
|
1252
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
1253
|
+
password?: pulumi.Input<string>;
|
|
1254
|
+
port?: pulumi.Input<number>;
|
|
1255
|
+
portOverride?: pulumi.Input<number>;
|
|
1256
|
+
/**
|
|
1257
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1258
|
+
*/
|
|
1259
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1260
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1261
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1262
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1263
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1264
|
+
/**
|
|
1265
|
+
* Tags is a map of key, value pairs.
|
|
1266
|
+
*/
|
|
1267
|
+
tags?: pulumi.Input<{
|
|
1268
|
+
[key: string]: pulumi.Input<string>;
|
|
1269
|
+
}>;
|
|
1270
|
+
username?: pulumi.Input<string>;
|
|
1271
|
+
}
|
|
1272
|
+
export interface ResourceHttpAuth {
|
|
1273
|
+
authHeader?: pulumi.Input<string>;
|
|
1274
|
+
/**
|
|
1275
|
+
* Bind interface
|
|
1276
|
+
*/
|
|
1277
|
+
bindInterface?: pulumi.Input<string>;
|
|
1278
|
+
defaultPath?: pulumi.Input<string>;
|
|
1279
|
+
/**
|
|
1280
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1281
|
+
*/
|
|
1282
|
+
egressFilter?: pulumi.Input<string>;
|
|
1283
|
+
headersBlacklist?: pulumi.Input<string>;
|
|
1284
|
+
healthcheckPath: pulumi.Input<string>;
|
|
1285
|
+
/**
|
|
1286
|
+
* Unique human-readable name of the Resource.
|
|
1287
|
+
*/
|
|
1288
|
+
name: pulumi.Input<string>;
|
|
1289
|
+
secretStoreAuthHeaderKey?: pulumi.Input<string>;
|
|
1290
|
+
secretStoreAuthHeaderPath?: pulumi.Input<string>;
|
|
1291
|
+
/**
|
|
1292
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1293
|
+
*/
|
|
1294
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1295
|
+
subdomain: pulumi.Input<string>;
|
|
1296
|
+
/**
|
|
1297
|
+
* Tags is a map of key, value pairs.
|
|
1298
|
+
*/
|
|
1299
|
+
tags?: pulumi.Input<{
|
|
1300
|
+
[key: string]: pulumi.Input<string>;
|
|
1301
|
+
}>;
|
|
1302
|
+
/**
|
|
1303
|
+
* * kubernetes:
|
|
1304
|
+
*/
|
|
1305
|
+
url: pulumi.Input<string>;
|
|
1306
|
+
}
|
|
1307
|
+
export interface ResourceHttpBasicAuth {
|
|
1308
|
+
/**
|
|
1309
|
+
* Bind interface
|
|
1310
|
+
*/
|
|
1311
|
+
bindInterface?: pulumi.Input<string>;
|
|
1312
|
+
defaultPath?: pulumi.Input<string>;
|
|
1313
|
+
/**
|
|
1314
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1315
|
+
*/
|
|
1316
|
+
egressFilter?: pulumi.Input<string>;
|
|
1317
|
+
headersBlacklist?: pulumi.Input<string>;
|
|
1318
|
+
healthcheckPath: pulumi.Input<string>;
|
|
1319
|
+
/**
|
|
1320
|
+
* Unique human-readable name of the Resource.
|
|
1321
|
+
*/
|
|
1322
|
+
name: pulumi.Input<string>;
|
|
1323
|
+
password?: pulumi.Input<string>;
|
|
1324
|
+
/**
|
|
1325
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1326
|
+
*/
|
|
1327
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1328
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1329
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1330
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1331
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1332
|
+
subdomain: pulumi.Input<string>;
|
|
1333
|
+
/**
|
|
1334
|
+
* Tags is a map of key, value pairs.
|
|
1335
|
+
*/
|
|
1336
|
+
tags?: pulumi.Input<{
|
|
1337
|
+
[key: string]: pulumi.Input<string>;
|
|
1338
|
+
}>;
|
|
1339
|
+
/**
|
|
1340
|
+
* * kubernetes:
|
|
1341
|
+
*/
|
|
1342
|
+
url: pulumi.Input<string>;
|
|
1343
|
+
username?: pulumi.Input<string>;
|
|
1344
|
+
}
|
|
1345
|
+
export interface ResourceHttpNoAuth {
|
|
1346
|
+
/**
|
|
1347
|
+
* Bind interface
|
|
1348
|
+
*/
|
|
1349
|
+
bindInterface?: pulumi.Input<string>;
|
|
1350
|
+
defaultPath?: pulumi.Input<string>;
|
|
1351
|
+
/**
|
|
1352
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1353
|
+
*/
|
|
1354
|
+
egressFilter?: pulumi.Input<string>;
|
|
1355
|
+
headersBlacklist?: pulumi.Input<string>;
|
|
1356
|
+
healthcheckPath: pulumi.Input<string>;
|
|
1357
|
+
/**
|
|
1358
|
+
* Unique human-readable name of the Resource.
|
|
1359
|
+
*/
|
|
1360
|
+
name: pulumi.Input<string>;
|
|
1361
|
+
/**
|
|
1362
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1363
|
+
*/
|
|
1364
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1365
|
+
subdomain: pulumi.Input<string>;
|
|
1366
|
+
/**
|
|
1367
|
+
* Tags is a map of key, value pairs.
|
|
1368
|
+
*/
|
|
1369
|
+
tags?: pulumi.Input<{
|
|
1370
|
+
[key: string]: pulumi.Input<string>;
|
|
1371
|
+
}>;
|
|
1372
|
+
/**
|
|
1373
|
+
* * kubernetes:
|
|
1374
|
+
*/
|
|
1375
|
+
url: pulumi.Input<string>;
|
|
1376
|
+
}
|
|
1377
|
+
export interface ResourceKubernetes {
|
|
1378
|
+
/**
|
|
1379
|
+
* Bind interface
|
|
1380
|
+
*/
|
|
1381
|
+
bindInterface?: pulumi.Input<string>;
|
|
1382
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1383
|
+
clientCertificate?: pulumi.Input<string>;
|
|
1384
|
+
clientKey?: pulumi.Input<string>;
|
|
1385
|
+
/**
|
|
1386
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1387
|
+
*/
|
|
1388
|
+
egressFilter?: pulumi.Input<string>;
|
|
1389
|
+
/**
|
|
1390
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1391
|
+
*/
|
|
1392
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1393
|
+
hostname: pulumi.Input<string>;
|
|
1394
|
+
/**
|
|
1395
|
+
* Unique human-readable name of the Resource.
|
|
1396
|
+
*/
|
|
1397
|
+
name: pulumi.Input<string>;
|
|
1398
|
+
port: pulumi.Input<number>;
|
|
1399
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
1400
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
1401
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1402
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1403
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
1404
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
1405
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
1406
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
1407
|
+
/**
|
|
1408
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1409
|
+
*/
|
|
1410
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1411
|
+
/**
|
|
1412
|
+
* Tags is a map of key, value pairs.
|
|
1413
|
+
*/
|
|
1414
|
+
tags?: pulumi.Input<{
|
|
1415
|
+
[key: string]: pulumi.Input<string>;
|
|
1416
|
+
}>;
|
|
1417
|
+
}
|
|
1418
|
+
export interface ResourceKubernetesBasicAuth {
|
|
1419
|
+
/**
|
|
1420
|
+
* Bind interface
|
|
1421
|
+
*/
|
|
1422
|
+
bindInterface?: pulumi.Input<string>;
|
|
1423
|
+
/**
|
|
1424
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1425
|
+
*/
|
|
1426
|
+
egressFilter?: pulumi.Input<string>;
|
|
1427
|
+
/**
|
|
1428
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1429
|
+
*/
|
|
1430
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1431
|
+
hostname: pulumi.Input<string>;
|
|
1432
|
+
/**
|
|
1433
|
+
* Unique human-readable name of the Resource.
|
|
1434
|
+
*/
|
|
1435
|
+
name: pulumi.Input<string>;
|
|
1436
|
+
password?: pulumi.Input<string>;
|
|
1437
|
+
port: pulumi.Input<number>;
|
|
1438
|
+
/**
|
|
1439
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1440
|
+
*/
|
|
1441
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1442
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1443
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1444
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1445
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1446
|
+
/**
|
|
1447
|
+
* Tags is a map of key, value pairs.
|
|
1448
|
+
*/
|
|
1449
|
+
tags?: pulumi.Input<{
|
|
1450
|
+
[key: string]: pulumi.Input<string>;
|
|
1451
|
+
}>;
|
|
1452
|
+
username?: pulumi.Input<string>;
|
|
1453
|
+
}
|
|
1454
|
+
export interface ResourceKubernetesServiceAccount {
|
|
1455
|
+
/**
|
|
1456
|
+
* Bind interface
|
|
1457
|
+
*/
|
|
1458
|
+
bindInterface?: pulumi.Input<string>;
|
|
1459
|
+
/**
|
|
1460
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1461
|
+
*/
|
|
1462
|
+
egressFilter?: pulumi.Input<string>;
|
|
1463
|
+
/**
|
|
1464
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1465
|
+
*/
|
|
1466
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1467
|
+
hostname: pulumi.Input<string>;
|
|
1468
|
+
/**
|
|
1469
|
+
* Unique human-readable name of the Resource.
|
|
1470
|
+
*/
|
|
1471
|
+
name: pulumi.Input<string>;
|
|
1472
|
+
port: pulumi.Input<number>;
|
|
1473
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
1474
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
1475
|
+
/**
|
|
1476
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1477
|
+
*/
|
|
1478
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1479
|
+
/**
|
|
1480
|
+
* * kubernetes_user_impersonation:
|
|
1481
|
+
*/
|
|
1482
|
+
secretStoreTokenKey?: pulumi.Input<string>;
|
|
1483
|
+
secretStoreTokenPath?: pulumi.Input<string>;
|
|
1484
|
+
/**
|
|
1485
|
+
* Tags is a map of key, value pairs.
|
|
1486
|
+
*/
|
|
1487
|
+
tags?: pulumi.Input<{
|
|
1488
|
+
[key: string]: pulumi.Input<string>;
|
|
1489
|
+
}>;
|
|
1490
|
+
token?: pulumi.Input<string>;
|
|
1491
|
+
}
|
|
1492
|
+
export interface ResourceKubernetesServiceAccountUserImpersonation {
|
|
1493
|
+
/**
|
|
1494
|
+
* Bind interface
|
|
1495
|
+
*/
|
|
1496
|
+
bindInterface?: pulumi.Input<string>;
|
|
1497
|
+
/**
|
|
1498
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1499
|
+
*/
|
|
1500
|
+
egressFilter?: pulumi.Input<string>;
|
|
1501
|
+
/**
|
|
1502
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1503
|
+
*/
|
|
1504
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1505
|
+
hostname: pulumi.Input<string>;
|
|
1506
|
+
/**
|
|
1507
|
+
* Unique human-readable name of the Resource.
|
|
1508
|
+
*/
|
|
1509
|
+
name: pulumi.Input<string>;
|
|
1510
|
+
port: pulumi.Input<number>;
|
|
1511
|
+
/**
|
|
1512
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1513
|
+
*/
|
|
1514
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1515
|
+
/**
|
|
1516
|
+
* * kubernetes_user_impersonation:
|
|
1517
|
+
*/
|
|
1518
|
+
secretStoreTokenKey?: pulumi.Input<string>;
|
|
1519
|
+
secretStoreTokenPath?: pulumi.Input<string>;
|
|
1520
|
+
/**
|
|
1521
|
+
* Tags is a map of key, value pairs.
|
|
1522
|
+
*/
|
|
1523
|
+
tags?: pulumi.Input<{
|
|
1524
|
+
[key: string]: pulumi.Input<string>;
|
|
1525
|
+
}>;
|
|
1526
|
+
token?: pulumi.Input<string>;
|
|
1527
|
+
}
|
|
1528
|
+
export interface ResourceKubernetesUserImpersonation {
|
|
1529
|
+
/**
|
|
1530
|
+
* Bind interface
|
|
1531
|
+
*/
|
|
1532
|
+
bindInterface?: pulumi.Input<string>;
|
|
1533
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1534
|
+
clientCertificate?: pulumi.Input<string>;
|
|
1535
|
+
clientKey?: pulumi.Input<string>;
|
|
1536
|
+
/**
|
|
1537
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1538
|
+
*/
|
|
1539
|
+
egressFilter?: pulumi.Input<string>;
|
|
1540
|
+
/**
|
|
1541
|
+
* The path used to check the health of your connection. Defaults to `default`. This field is required, and is only marked as optional for backwards compatibility.
|
|
1542
|
+
*/
|
|
1543
|
+
healthcheckNamespace?: pulumi.Input<string>;
|
|
1544
|
+
hostname: pulumi.Input<string>;
|
|
1545
|
+
/**
|
|
1546
|
+
* Unique human-readable name of the Resource.
|
|
1547
|
+
*/
|
|
1548
|
+
name: pulumi.Input<string>;
|
|
1549
|
+
port: pulumi.Input<number>;
|
|
1550
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1551
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1552
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
1553
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
1554
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
1555
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
1556
|
+
/**
|
|
1557
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1558
|
+
*/
|
|
1559
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1560
|
+
/**
|
|
1561
|
+
* Tags is a map of key, value pairs.
|
|
1562
|
+
*/
|
|
1563
|
+
tags?: pulumi.Input<{
|
|
1564
|
+
[key: string]: pulumi.Input<string>;
|
|
1565
|
+
}>;
|
|
1566
|
+
}
|
|
1567
|
+
export interface ResourceMaria {
|
|
1568
|
+
/**
|
|
1569
|
+
* Bind interface
|
|
1570
|
+
*/
|
|
1571
|
+
bindInterface?: pulumi.Input<string>;
|
|
1572
|
+
database: pulumi.Input<string>;
|
|
1573
|
+
/**
|
|
1574
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1575
|
+
*/
|
|
1576
|
+
egressFilter?: pulumi.Input<string>;
|
|
1577
|
+
hostname: pulumi.Input<string>;
|
|
1578
|
+
/**
|
|
1579
|
+
* Unique human-readable name of the Resource.
|
|
1580
|
+
*/
|
|
1581
|
+
name: pulumi.Input<string>;
|
|
1582
|
+
password?: pulumi.Input<string>;
|
|
1583
|
+
port?: pulumi.Input<number>;
|
|
1584
|
+
portOverride?: pulumi.Input<number>;
|
|
1585
|
+
/**
|
|
1586
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1587
|
+
*/
|
|
1588
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1589
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1590
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1591
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1592
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1593
|
+
/**
|
|
1594
|
+
* Tags is a map of key, value pairs.
|
|
1595
|
+
*/
|
|
1596
|
+
tags?: pulumi.Input<{
|
|
1597
|
+
[key: string]: pulumi.Input<string>;
|
|
1598
|
+
}>;
|
|
1599
|
+
username?: pulumi.Input<string>;
|
|
1600
|
+
}
|
|
1601
|
+
export interface ResourceMemcached {
|
|
1602
|
+
/**
|
|
1603
|
+
* Bind interface
|
|
1604
|
+
*/
|
|
1605
|
+
bindInterface?: pulumi.Input<string>;
|
|
1606
|
+
/**
|
|
1607
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1608
|
+
*/
|
|
1609
|
+
egressFilter?: pulumi.Input<string>;
|
|
1610
|
+
hostname: pulumi.Input<string>;
|
|
1611
|
+
/**
|
|
1612
|
+
* Unique human-readable name of the Resource.
|
|
1613
|
+
*/
|
|
1614
|
+
name: pulumi.Input<string>;
|
|
1615
|
+
port?: pulumi.Input<number>;
|
|
1616
|
+
portOverride?: pulumi.Input<number>;
|
|
1617
|
+
/**
|
|
1618
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1619
|
+
*/
|
|
1620
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1621
|
+
/**
|
|
1622
|
+
* Tags is a map of key, value pairs.
|
|
1623
|
+
*/
|
|
1624
|
+
tags?: pulumi.Input<{
|
|
1625
|
+
[key: string]: pulumi.Input<string>;
|
|
1626
|
+
}>;
|
|
1627
|
+
}
|
|
1628
|
+
export interface ResourceMemsql {
|
|
1629
|
+
/**
|
|
1630
|
+
* Bind interface
|
|
1631
|
+
*/
|
|
1632
|
+
bindInterface?: pulumi.Input<string>;
|
|
1633
|
+
database: pulumi.Input<string>;
|
|
1634
|
+
/**
|
|
1635
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1636
|
+
*/
|
|
1637
|
+
egressFilter?: pulumi.Input<string>;
|
|
1638
|
+
hostname: pulumi.Input<string>;
|
|
1639
|
+
/**
|
|
1640
|
+
* Unique human-readable name of the Resource.
|
|
1641
|
+
*/
|
|
1642
|
+
name: pulumi.Input<string>;
|
|
1643
|
+
password?: pulumi.Input<string>;
|
|
1644
|
+
port?: pulumi.Input<number>;
|
|
1645
|
+
portOverride?: pulumi.Input<number>;
|
|
1646
|
+
/**
|
|
1647
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1648
|
+
*/
|
|
1649
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1650
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1651
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1652
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1653
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1654
|
+
/**
|
|
1655
|
+
* Tags is a map of key, value pairs.
|
|
1656
|
+
*/
|
|
1657
|
+
tags?: pulumi.Input<{
|
|
1658
|
+
[key: string]: pulumi.Input<string>;
|
|
1659
|
+
}>;
|
|
1660
|
+
username?: pulumi.Input<string>;
|
|
1661
|
+
}
|
|
1662
|
+
export interface ResourceMongoHost {
|
|
1663
|
+
authDatabase: pulumi.Input<string>;
|
|
1664
|
+
/**
|
|
1665
|
+
* Bind interface
|
|
1666
|
+
*/
|
|
1667
|
+
bindInterface?: pulumi.Input<string>;
|
|
1668
|
+
/**
|
|
1669
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1670
|
+
*/
|
|
1671
|
+
egressFilter?: pulumi.Input<string>;
|
|
1672
|
+
hostname: pulumi.Input<string>;
|
|
1673
|
+
/**
|
|
1674
|
+
* Unique human-readable name of the Resource.
|
|
1675
|
+
*/
|
|
1676
|
+
name: pulumi.Input<string>;
|
|
1677
|
+
password?: pulumi.Input<string>;
|
|
1678
|
+
port?: pulumi.Input<number>;
|
|
1679
|
+
portOverride?: pulumi.Input<number>;
|
|
1680
|
+
/**
|
|
1681
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1682
|
+
*/
|
|
1683
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1684
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1685
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1686
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1687
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1688
|
+
/**
|
|
1689
|
+
* Tags is a map of key, value pairs.
|
|
1690
|
+
*/
|
|
1691
|
+
tags?: pulumi.Input<{
|
|
1692
|
+
[key: string]: pulumi.Input<string>;
|
|
1693
|
+
}>;
|
|
1694
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1695
|
+
username?: pulumi.Input<string>;
|
|
1696
|
+
}
|
|
1697
|
+
export interface ResourceMongoLegacyHost {
|
|
1698
|
+
authDatabase: pulumi.Input<string>;
|
|
1699
|
+
/**
|
|
1700
|
+
* Bind interface
|
|
1701
|
+
*/
|
|
1702
|
+
bindInterface?: pulumi.Input<string>;
|
|
1703
|
+
/**
|
|
1704
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1705
|
+
*/
|
|
1706
|
+
egressFilter?: pulumi.Input<string>;
|
|
1707
|
+
hostname: pulumi.Input<string>;
|
|
1708
|
+
/**
|
|
1709
|
+
* Unique human-readable name of the Resource.
|
|
1710
|
+
*/
|
|
1711
|
+
name: pulumi.Input<string>;
|
|
1712
|
+
password?: pulumi.Input<string>;
|
|
1713
|
+
port?: pulumi.Input<number>;
|
|
1714
|
+
portOverride?: pulumi.Input<number>;
|
|
1715
|
+
replicaSet?: pulumi.Input<string>;
|
|
1716
|
+
/**
|
|
1717
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1718
|
+
*/
|
|
1719
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1720
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1721
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1722
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1723
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1724
|
+
/**
|
|
1725
|
+
* Tags is a map of key, value pairs.
|
|
1726
|
+
*/
|
|
1727
|
+
tags?: pulumi.Input<{
|
|
1728
|
+
[key: string]: pulumi.Input<string>;
|
|
1729
|
+
}>;
|
|
1730
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1731
|
+
username?: pulumi.Input<string>;
|
|
1732
|
+
}
|
|
1733
|
+
export interface ResourceMongoLegacyReplicaset {
|
|
1734
|
+
authDatabase: pulumi.Input<string>;
|
|
1735
|
+
/**
|
|
1736
|
+
* Bind interface
|
|
1737
|
+
*/
|
|
1738
|
+
bindInterface?: pulumi.Input<string>;
|
|
1739
|
+
connectToReplica?: pulumi.Input<boolean>;
|
|
1740
|
+
/**
|
|
1741
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1742
|
+
*/
|
|
1743
|
+
egressFilter?: pulumi.Input<string>;
|
|
1744
|
+
hostname: pulumi.Input<string>;
|
|
1745
|
+
/**
|
|
1746
|
+
* Unique human-readable name of the Resource.
|
|
1747
|
+
*/
|
|
1748
|
+
name: pulumi.Input<string>;
|
|
1749
|
+
password?: pulumi.Input<string>;
|
|
1750
|
+
port?: pulumi.Input<number>;
|
|
1751
|
+
portOverride?: pulumi.Input<number>;
|
|
1752
|
+
replicaSet: pulumi.Input<string>;
|
|
1753
|
+
/**
|
|
1754
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1755
|
+
*/
|
|
1756
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1757
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1758
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1759
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1760
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1761
|
+
/**
|
|
1762
|
+
* Tags is a map of key, value pairs.
|
|
1763
|
+
*/
|
|
1764
|
+
tags?: pulumi.Input<{
|
|
1765
|
+
[key: string]: pulumi.Input<string>;
|
|
1766
|
+
}>;
|
|
1767
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1768
|
+
username?: pulumi.Input<string>;
|
|
1769
|
+
}
|
|
1770
|
+
export interface ResourceMongoReplicaSet {
|
|
1771
|
+
authDatabase: pulumi.Input<string>;
|
|
1772
|
+
/**
|
|
1773
|
+
* Bind interface
|
|
1774
|
+
*/
|
|
1775
|
+
bindInterface?: pulumi.Input<string>;
|
|
1776
|
+
connectToReplica?: pulumi.Input<boolean>;
|
|
1777
|
+
/**
|
|
1778
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1779
|
+
*/
|
|
1780
|
+
egressFilter?: pulumi.Input<string>;
|
|
1781
|
+
hostname: pulumi.Input<string>;
|
|
1782
|
+
/**
|
|
1783
|
+
* Unique human-readable name of the Resource.
|
|
1784
|
+
*/
|
|
1785
|
+
name: pulumi.Input<string>;
|
|
1786
|
+
password?: pulumi.Input<string>;
|
|
1787
|
+
port?: pulumi.Input<number>;
|
|
1788
|
+
portOverride?: pulumi.Input<number>;
|
|
1789
|
+
replicaSet: pulumi.Input<string>;
|
|
1790
|
+
/**
|
|
1791
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1792
|
+
*/
|
|
1793
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1794
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1795
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1796
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1797
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1798
|
+
/**
|
|
1799
|
+
* Tags is a map of key, value pairs.
|
|
1800
|
+
*/
|
|
1801
|
+
tags?: pulumi.Input<{
|
|
1802
|
+
[key: string]: pulumi.Input<string>;
|
|
1803
|
+
}>;
|
|
1804
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1805
|
+
username?: pulumi.Input<string>;
|
|
1806
|
+
}
|
|
1807
|
+
export interface ResourceMongoShardedCluster {
|
|
1808
|
+
authDatabase: pulumi.Input<string>;
|
|
1809
|
+
/**
|
|
1810
|
+
* Bind interface
|
|
1811
|
+
*/
|
|
1812
|
+
bindInterface?: pulumi.Input<string>;
|
|
1813
|
+
/**
|
|
1814
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1815
|
+
*/
|
|
1816
|
+
egressFilter?: pulumi.Input<string>;
|
|
1817
|
+
hostname: pulumi.Input<string>;
|
|
1818
|
+
/**
|
|
1819
|
+
* Unique human-readable name of the Resource.
|
|
1820
|
+
*/
|
|
1821
|
+
name: pulumi.Input<string>;
|
|
1822
|
+
password?: pulumi.Input<string>;
|
|
1823
|
+
portOverride?: pulumi.Input<number>;
|
|
1824
|
+
/**
|
|
1825
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1826
|
+
*/
|
|
1827
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1828
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1829
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1830
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1831
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1832
|
+
/**
|
|
1833
|
+
* Tags is a map of key, value pairs.
|
|
1834
|
+
*/
|
|
1835
|
+
tags?: pulumi.Input<{
|
|
1836
|
+
[key: string]: pulumi.Input<string>;
|
|
1837
|
+
}>;
|
|
1838
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
1839
|
+
username?: pulumi.Input<string>;
|
|
1840
|
+
}
|
|
1841
|
+
export interface ResourceMtlsMysql {
|
|
1842
|
+
/**
|
|
1843
|
+
* Bind interface
|
|
1844
|
+
*/
|
|
1845
|
+
bindInterface?: pulumi.Input<string>;
|
|
1846
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1847
|
+
clientCertificate?: pulumi.Input<string>;
|
|
1848
|
+
clientKey?: pulumi.Input<string>;
|
|
1849
|
+
database: pulumi.Input<string>;
|
|
1850
|
+
/**
|
|
1851
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1852
|
+
*/
|
|
1853
|
+
egressFilter?: pulumi.Input<string>;
|
|
1854
|
+
hostname: pulumi.Input<string>;
|
|
1855
|
+
/**
|
|
1856
|
+
* Unique human-readable name of the Resource.
|
|
1857
|
+
*/
|
|
1858
|
+
name: pulumi.Input<string>;
|
|
1859
|
+
password?: pulumi.Input<string>;
|
|
1860
|
+
port?: pulumi.Input<number>;
|
|
1861
|
+
portOverride?: pulumi.Input<number>;
|
|
1862
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1863
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1864
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
1865
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
1866
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
1867
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
1868
|
+
/**
|
|
1869
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1870
|
+
*/
|
|
1871
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1872
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1873
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1874
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1875
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1876
|
+
serverName?: pulumi.Input<string>;
|
|
1877
|
+
/**
|
|
1878
|
+
* Tags is a map of key, value pairs.
|
|
1879
|
+
*/
|
|
1880
|
+
tags?: pulumi.Input<{
|
|
1881
|
+
[key: string]: pulumi.Input<string>;
|
|
1882
|
+
}>;
|
|
1883
|
+
username?: pulumi.Input<string>;
|
|
1884
|
+
}
|
|
1885
|
+
export interface ResourceMtlsPostgres {
|
|
1886
|
+
/**
|
|
1887
|
+
* Bind interface
|
|
1888
|
+
*/
|
|
1889
|
+
bindInterface?: pulumi.Input<string>;
|
|
1890
|
+
certificateAuthority?: pulumi.Input<string>;
|
|
1891
|
+
clientCertificate?: pulumi.Input<string>;
|
|
1892
|
+
clientKey?: pulumi.Input<string>;
|
|
1893
|
+
database: pulumi.Input<string>;
|
|
1894
|
+
/**
|
|
1895
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1896
|
+
*/
|
|
1897
|
+
egressFilter?: pulumi.Input<string>;
|
|
1898
|
+
hostname: pulumi.Input<string>;
|
|
1899
|
+
/**
|
|
1900
|
+
* Unique human-readable name of the Resource.
|
|
1901
|
+
*/
|
|
1902
|
+
name: pulumi.Input<string>;
|
|
1903
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
1904
|
+
password?: pulumi.Input<string>;
|
|
1905
|
+
port?: pulumi.Input<number>;
|
|
1906
|
+
portOverride?: pulumi.Input<number>;
|
|
1907
|
+
secretStoreCertificateAuthorityKey?: pulumi.Input<string>;
|
|
1908
|
+
secretStoreCertificateAuthorityPath?: pulumi.Input<string>;
|
|
1909
|
+
secretStoreClientCertificateKey?: pulumi.Input<string>;
|
|
1910
|
+
secretStoreClientCertificatePath?: pulumi.Input<string>;
|
|
1911
|
+
secretStoreClientKeyKey?: pulumi.Input<string>;
|
|
1912
|
+
secretStoreClientKeyPath?: pulumi.Input<string>;
|
|
1913
|
+
/**
|
|
1914
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1915
|
+
*/
|
|
1916
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1917
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1918
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1919
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1920
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1921
|
+
serverName?: pulumi.Input<string>;
|
|
1922
|
+
/**
|
|
1923
|
+
* Tags is a map of key, value pairs.
|
|
1924
|
+
*/
|
|
1925
|
+
tags?: pulumi.Input<{
|
|
1926
|
+
[key: string]: pulumi.Input<string>;
|
|
1927
|
+
}>;
|
|
1928
|
+
username?: pulumi.Input<string>;
|
|
1929
|
+
}
|
|
1930
|
+
export interface ResourceMysql {
|
|
1931
|
+
/**
|
|
1932
|
+
* Bind interface
|
|
1933
|
+
*/
|
|
1934
|
+
bindInterface?: pulumi.Input<string>;
|
|
1935
|
+
database: pulumi.Input<string>;
|
|
1936
|
+
/**
|
|
1937
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1938
|
+
*/
|
|
1939
|
+
egressFilter?: pulumi.Input<string>;
|
|
1940
|
+
hostname: pulumi.Input<string>;
|
|
1941
|
+
/**
|
|
1942
|
+
* Unique human-readable name of the Resource.
|
|
1943
|
+
*/
|
|
1944
|
+
name: pulumi.Input<string>;
|
|
1945
|
+
password?: pulumi.Input<string>;
|
|
1946
|
+
port?: pulumi.Input<number>;
|
|
1947
|
+
portOverride?: pulumi.Input<number>;
|
|
1948
|
+
/**
|
|
1949
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1950
|
+
*/
|
|
1951
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1952
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
1953
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
1954
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
1955
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
1956
|
+
/**
|
|
1957
|
+
* Tags is a map of key, value pairs.
|
|
1958
|
+
*/
|
|
1959
|
+
tags?: pulumi.Input<{
|
|
1960
|
+
[key: string]: pulumi.Input<string>;
|
|
1961
|
+
}>;
|
|
1962
|
+
username?: pulumi.Input<string>;
|
|
1963
|
+
}
|
|
1964
|
+
export interface ResourceNeptune {
|
|
1965
|
+
/**
|
|
1966
|
+
* Bind interface
|
|
1967
|
+
*/
|
|
1968
|
+
bindInterface?: pulumi.Input<string>;
|
|
1969
|
+
/**
|
|
1970
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1971
|
+
*/
|
|
1972
|
+
egressFilter?: pulumi.Input<string>;
|
|
1973
|
+
endpoint: pulumi.Input<string>;
|
|
1974
|
+
/**
|
|
1975
|
+
* Unique human-readable name of the Resource.
|
|
1976
|
+
*/
|
|
1977
|
+
name: pulumi.Input<string>;
|
|
1978
|
+
port?: pulumi.Input<number>;
|
|
1979
|
+
portOverride?: pulumi.Input<number>;
|
|
1980
|
+
/**
|
|
1981
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
1982
|
+
*/
|
|
1983
|
+
secretStoreId?: pulumi.Input<string>;
|
|
1984
|
+
/**
|
|
1985
|
+
* Tags is a map of key, value pairs.
|
|
1986
|
+
*/
|
|
1987
|
+
tags?: pulumi.Input<{
|
|
1988
|
+
[key: string]: pulumi.Input<string>;
|
|
1989
|
+
}>;
|
|
1990
|
+
}
|
|
1991
|
+
export interface ResourceNeptuneIam {
|
|
1992
|
+
accessKey?: pulumi.Input<string>;
|
|
1993
|
+
/**
|
|
1994
|
+
* Bind interface
|
|
1995
|
+
*/
|
|
1996
|
+
bindInterface?: pulumi.Input<string>;
|
|
1997
|
+
/**
|
|
1998
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
1999
|
+
*/
|
|
2000
|
+
egressFilter?: pulumi.Input<string>;
|
|
2001
|
+
endpoint: pulumi.Input<string>;
|
|
2002
|
+
/**
|
|
2003
|
+
* Unique human-readable name of the Resource.
|
|
2004
|
+
*/
|
|
2005
|
+
name: pulumi.Input<string>;
|
|
2006
|
+
port?: pulumi.Input<number>;
|
|
2007
|
+
portOverride?: pulumi.Input<number>;
|
|
2008
|
+
region: pulumi.Input<string>;
|
|
2009
|
+
roleArn?: pulumi.Input<string>;
|
|
2010
|
+
roleExternalId?: pulumi.Input<string>;
|
|
2011
|
+
secretAccessKey?: pulumi.Input<string>;
|
|
2012
|
+
secretStoreAccessKeyKey?: pulumi.Input<string>;
|
|
2013
|
+
secretStoreAccessKeyPath?: pulumi.Input<string>;
|
|
2014
|
+
/**
|
|
2015
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2016
|
+
*/
|
|
2017
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2018
|
+
secretStoreRoleArnKey?: pulumi.Input<string>;
|
|
2019
|
+
secretStoreRoleArnPath?: pulumi.Input<string>;
|
|
2020
|
+
secretStoreRoleExternalIdKey?: pulumi.Input<string>;
|
|
2021
|
+
secretStoreRoleExternalIdPath?: pulumi.Input<string>;
|
|
2022
|
+
secretStoreSecretAccessKeyKey?: pulumi.Input<string>;
|
|
2023
|
+
secretStoreSecretAccessKeyPath?: pulumi.Input<string>;
|
|
2024
|
+
/**
|
|
2025
|
+
* Tags is a map of key, value pairs.
|
|
2026
|
+
*/
|
|
2027
|
+
tags?: pulumi.Input<{
|
|
2028
|
+
[key: string]: pulumi.Input<string>;
|
|
2029
|
+
}>;
|
|
2030
|
+
}
|
|
2031
|
+
export interface ResourceOracle {
|
|
2032
|
+
/**
|
|
2033
|
+
* Bind interface
|
|
2034
|
+
*/
|
|
2035
|
+
bindInterface?: pulumi.Input<string>;
|
|
2036
|
+
database: pulumi.Input<string>;
|
|
2037
|
+
/**
|
|
2038
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2039
|
+
*/
|
|
2040
|
+
egressFilter?: pulumi.Input<string>;
|
|
2041
|
+
hostname: pulumi.Input<string>;
|
|
2042
|
+
/**
|
|
2043
|
+
* Unique human-readable name of the Resource.
|
|
2044
|
+
*/
|
|
2045
|
+
name: pulumi.Input<string>;
|
|
2046
|
+
password?: pulumi.Input<string>;
|
|
2047
|
+
port: pulumi.Input<number>;
|
|
2048
|
+
portOverride?: pulumi.Input<number>;
|
|
2049
|
+
/**
|
|
2050
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2051
|
+
*/
|
|
2052
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2053
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2054
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2055
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2056
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2057
|
+
/**
|
|
2058
|
+
* Tags is a map of key, value pairs.
|
|
2059
|
+
*/
|
|
2060
|
+
tags?: pulumi.Input<{
|
|
2061
|
+
[key: string]: pulumi.Input<string>;
|
|
2062
|
+
}>;
|
|
2063
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
2064
|
+
username?: pulumi.Input<string>;
|
|
2065
|
+
}
|
|
2066
|
+
export interface ResourcePostgres {
|
|
2067
|
+
/**
|
|
2068
|
+
* Bind interface
|
|
2069
|
+
*/
|
|
2070
|
+
bindInterface?: pulumi.Input<string>;
|
|
2071
|
+
database: pulumi.Input<string>;
|
|
2072
|
+
/**
|
|
2073
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2074
|
+
*/
|
|
2075
|
+
egressFilter?: pulumi.Input<string>;
|
|
2076
|
+
hostname: pulumi.Input<string>;
|
|
2077
|
+
/**
|
|
2078
|
+
* Unique human-readable name of the Resource.
|
|
2079
|
+
*/
|
|
2080
|
+
name: pulumi.Input<string>;
|
|
2081
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
2082
|
+
password?: pulumi.Input<string>;
|
|
2083
|
+
port?: pulumi.Input<number>;
|
|
2084
|
+
portOverride?: pulumi.Input<number>;
|
|
2085
|
+
/**
|
|
2086
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2087
|
+
*/
|
|
2088
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2089
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2090
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2091
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2092
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2093
|
+
/**
|
|
2094
|
+
* Tags is a map of key, value pairs.
|
|
2095
|
+
*/
|
|
2096
|
+
tags?: pulumi.Input<{
|
|
2097
|
+
[key: string]: pulumi.Input<string>;
|
|
2098
|
+
}>;
|
|
2099
|
+
username?: pulumi.Input<string>;
|
|
2100
|
+
}
|
|
2101
|
+
export interface ResourcePresto {
|
|
2102
|
+
/**
|
|
2103
|
+
* Bind interface
|
|
2104
|
+
*/
|
|
2105
|
+
bindInterface?: pulumi.Input<string>;
|
|
2106
|
+
database: pulumi.Input<string>;
|
|
2107
|
+
/**
|
|
2108
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2109
|
+
*/
|
|
2110
|
+
egressFilter?: pulumi.Input<string>;
|
|
2111
|
+
hostname: pulumi.Input<string>;
|
|
2112
|
+
/**
|
|
2113
|
+
* Unique human-readable name of the Resource.
|
|
2114
|
+
*/
|
|
2115
|
+
name: pulumi.Input<string>;
|
|
2116
|
+
password?: pulumi.Input<string>;
|
|
2117
|
+
port?: pulumi.Input<number>;
|
|
2118
|
+
portOverride?: pulumi.Input<number>;
|
|
2119
|
+
/**
|
|
2120
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2121
|
+
*/
|
|
2122
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2123
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2124
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2125
|
+
/**
|
|
2126
|
+
* Tags is a map of key, value pairs.
|
|
2127
|
+
*/
|
|
2128
|
+
tags?: pulumi.Input<{
|
|
2129
|
+
[key: string]: pulumi.Input<string>;
|
|
2130
|
+
}>;
|
|
2131
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
2132
|
+
username?: pulumi.Input<string>;
|
|
2133
|
+
}
|
|
2134
|
+
export interface ResourceRabbitmqAmqp091 {
|
|
2135
|
+
/**
|
|
2136
|
+
* Bind interface
|
|
2137
|
+
*/
|
|
2138
|
+
bindInterface?: pulumi.Input<string>;
|
|
2139
|
+
/**
|
|
2140
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2141
|
+
*/
|
|
2142
|
+
egressFilter?: pulumi.Input<string>;
|
|
2143
|
+
hostname: pulumi.Input<string>;
|
|
2144
|
+
/**
|
|
2145
|
+
* Unique human-readable name of the Resource.
|
|
2146
|
+
*/
|
|
2147
|
+
name: pulumi.Input<string>;
|
|
2148
|
+
password?: pulumi.Input<string>;
|
|
2149
|
+
port?: pulumi.Input<number>;
|
|
2150
|
+
portOverride?: pulumi.Input<number>;
|
|
2151
|
+
/**
|
|
2152
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2153
|
+
*/
|
|
2154
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2155
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2156
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2157
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2158
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2159
|
+
/**
|
|
2160
|
+
* Tags is a map of key, value pairs.
|
|
2161
|
+
*/
|
|
2162
|
+
tags?: pulumi.Input<{
|
|
2163
|
+
[key: string]: pulumi.Input<string>;
|
|
2164
|
+
}>;
|
|
2165
|
+
tlsRequired?: pulumi.Input<boolean>;
|
|
2166
|
+
username?: pulumi.Input<string>;
|
|
2167
|
+
}
|
|
2168
|
+
export interface ResourceRawTcp {
|
|
2169
|
+
/**
|
|
2170
|
+
* Bind interface
|
|
2171
|
+
*/
|
|
2172
|
+
bindInterface?: pulumi.Input<string>;
|
|
2173
|
+
/**
|
|
2174
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2175
|
+
*/
|
|
2176
|
+
egressFilter?: pulumi.Input<string>;
|
|
2177
|
+
hostname: pulumi.Input<string>;
|
|
2178
|
+
/**
|
|
2179
|
+
* Unique human-readable name of the Resource.
|
|
2180
|
+
*/
|
|
2181
|
+
name: pulumi.Input<string>;
|
|
2182
|
+
port?: pulumi.Input<number>;
|
|
2183
|
+
portOverride?: pulumi.Input<number>;
|
|
2184
|
+
/**
|
|
2185
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2186
|
+
*/
|
|
2187
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2188
|
+
/**
|
|
2189
|
+
* Tags is a map of key, value pairs.
|
|
2190
|
+
*/
|
|
2191
|
+
tags?: pulumi.Input<{
|
|
2192
|
+
[key: string]: pulumi.Input<string>;
|
|
2193
|
+
}>;
|
|
2194
|
+
}
|
|
2195
|
+
export interface ResourceRdp {
|
|
2196
|
+
/**
|
|
2197
|
+
* Bind interface
|
|
2198
|
+
*/
|
|
2199
|
+
bindInterface?: pulumi.Input<string>;
|
|
2200
|
+
downgradeNlaConnections?: pulumi.Input<boolean>;
|
|
2201
|
+
/**
|
|
2202
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2203
|
+
*/
|
|
2204
|
+
egressFilter?: pulumi.Input<string>;
|
|
2205
|
+
hostname: pulumi.Input<string>;
|
|
2206
|
+
/**
|
|
2207
|
+
* Unique human-readable name of the Resource.
|
|
2208
|
+
*/
|
|
2209
|
+
name: pulumi.Input<string>;
|
|
2210
|
+
password?: pulumi.Input<string>;
|
|
2211
|
+
port: pulumi.Input<number>;
|
|
2212
|
+
portOverride?: pulumi.Input<number>;
|
|
2213
|
+
/**
|
|
2214
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2215
|
+
*/
|
|
2216
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2217
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2218
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2219
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2220
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2221
|
+
/**
|
|
2222
|
+
* Tags is a map of key, value pairs.
|
|
2223
|
+
*/
|
|
2224
|
+
tags?: pulumi.Input<{
|
|
2225
|
+
[key: string]: pulumi.Input<string>;
|
|
2226
|
+
}>;
|
|
2227
|
+
username?: pulumi.Input<string>;
|
|
2228
|
+
}
|
|
2229
|
+
export interface ResourceRedis {
|
|
2230
|
+
/**
|
|
2231
|
+
* Bind interface
|
|
2232
|
+
*/
|
|
2233
|
+
bindInterface?: pulumi.Input<string>;
|
|
2234
|
+
/**
|
|
2235
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2236
|
+
*/
|
|
2237
|
+
egressFilter?: pulumi.Input<string>;
|
|
2238
|
+
hostname: pulumi.Input<string>;
|
|
2239
|
+
/**
|
|
2240
|
+
* Unique human-readable name of the Resource.
|
|
2241
|
+
*/
|
|
2242
|
+
name: pulumi.Input<string>;
|
|
2243
|
+
password?: pulumi.Input<string>;
|
|
2244
|
+
port?: pulumi.Input<number>;
|
|
2245
|
+
portOverride?: pulumi.Input<number>;
|
|
2246
|
+
/**
|
|
2247
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2248
|
+
*/
|
|
2249
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2250
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2251
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2252
|
+
/**
|
|
2253
|
+
* Tags is a map of key, value pairs.
|
|
2254
|
+
*/
|
|
2255
|
+
tags?: pulumi.Input<{
|
|
2256
|
+
[key: string]: pulumi.Input<string>;
|
|
2257
|
+
}>;
|
|
2258
|
+
}
|
|
2259
|
+
export interface ResourceRedshift {
|
|
2260
|
+
/**
|
|
2261
|
+
* Bind interface
|
|
2262
|
+
*/
|
|
2263
|
+
bindInterface?: pulumi.Input<string>;
|
|
2264
|
+
database: pulumi.Input<string>;
|
|
2265
|
+
/**
|
|
2266
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2267
|
+
*/
|
|
2268
|
+
egressFilter?: pulumi.Input<string>;
|
|
2269
|
+
hostname: pulumi.Input<string>;
|
|
2270
|
+
/**
|
|
2271
|
+
* Unique human-readable name of the Resource.
|
|
2272
|
+
*/
|
|
2273
|
+
name: pulumi.Input<string>;
|
|
2274
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
2275
|
+
password?: pulumi.Input<string>;
|
|
2276
|
+
port?: pulumi.Input<number>;
|
|
2277
|
+
portOverride?: pulumi.Input<number>;
|
|
2278
|
+
/**
|
|
2279
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2280
|
+
*/
|
|
2281
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2282
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2283
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2284
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2285
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2286
|
+
/**
|
|
2287
|
+
* Tags is a map of key, value pairs.
|
|
2288
|
+
*/
|
|
2289
|
+
tags?: pulumi.Input<{
|
|
2290
|
+
[key: string]: pulumi.Input<string>;
|
|
2291
|
+
}>;
|
|
2292
|
+
username?: pulumi.Input<string>;
|
|
2293
|
+
}
|
|
2294
|
+
export interface ResourceSingleStore {
|
|
2295
|
+
/**
|
|
2296
|
+
* Bind interface
|
|
2297
|
+
*/
|
|
2298
|
+
bindInterface?: pulumi.Input<string>;
|
|
2299
|
+
database: pulumi.Input<string>;
|
|
2300
|
+
/**
|
|
2301
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2302
|
+
*/
|
|
2303
|
+
egressFilter?: pulumi.Input<string>;
|
|
2304
|
+
hostname: pulumi.Input<string>;
|
|
2305
|
+
/**
|
|
2306
|
+
* Unique human-readable name of the Resource.
|
|
2307
|
+
*/
|
|
2308
|
+
name: pulumi.Input<string>;
|
|
2309
|
+
password?: pulumi.Input<string>;
|
|
2310
|
+
port?: pulumi.Input<number>;
|
|
2311
|
+
portOverride?: pulumi.Input<number>;
|
|
2312
|
+
/**
|
|
2313
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2314
|
+
*/
|
|
2315
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2316
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2317
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2318
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2319
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2320
|
+
/**
|
|
2321
|
+
* Tags is a map of key, value pairs.
|
|
2322
|
+
*/
|
|
2323
|
+
tags?: pulumi.Input<{
|
|
2324
|
+
[key: string]: pulumi.Input<string>;
|
|
2325
|
+
}>;
|
|
2326
|
+
username?: pulumi.Input<string>;
|
|
2327
|
+
}
|
|
2328
|
+
export interface ResourceSnowflake {
|
|
2329
|
+
/**
|
|
2330
|
+
* Bind interface
|
|
2331
|
+
*/
|
|
2332
|
+
bindInterface?: pulumi.Input<string>;
|
|
2333
|
+
database: pulumi.Input<string>;
|
|
2334
|
+
/**
|
|
2335
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2336
|
+
*/
|
|
2337
|
+
egressFilter?: pulumi.Input<string>;
|
|
2338
|
+
hostname: pulumi.Input<string>;
|
|
2339
|
+
/**
|
|
2340
|
+
* Unique human-readable name of the Resource.
|
|
2341
|
+
*/
|
|
2342
|
+
name: pulumi.Input<string>;
|
|
2343
|
+
password?: pulumi.Input<string>;
|
|
2344
|
+
portOverride?: pulumi.Input<number>;
|
|
2345
|
+
schema?: pulumi.Input<string>;
|
|
2346
|
+
/**
|
|
2347
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2348
|
+
*/
|
|
2349
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2350
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2351
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2352
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2353
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2354
|
+
/**
|
|
2355
|
+
* Tags is a map of key, value pairs.
|
|
2356
|
+
*/
|
|
2357
|
+
tags?: pulumi.Input<{
|
|
2358
|
+
[key: string]: pulumi.Input<string>;
|
|
2359
|
+
}>;
|
|
2360
|
+
username?: pulumi.Input<string>;
|
|
2361
|
+
}
|
|
2362
|
+
export interface ResourceSqlServer {
|
|
2363
|
+
/**
|
|
2364
|
+
* Bind interface
|
|
2365
|
+
*/
|
|
2366
|
+
bindInterface?: pulumi.Input<string>;
|
|
2367
|
+
database: pulumi.Input<string>;
|
|
2368
|
+
/**
|
|
2369
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2370
|
+
*/
|
|
2371
|
+
egressFilter?: pulumi.Input<string>;
|
|
2372
|
+
hostname: pulumi.Input<string>;
|
|
2373
|
+
/**
|
|
2374
|
+
* Unique human-readable name of the Resource.
|
|
2375
|
+
*/
|
|
2376
|
+
name: pulumi.Input<string>;
|
|
2377
|
+
overrideDatabase?: pulumi.Input<boolean>;
|
|
2378
|
+
password?: pulumi.Input<string>;
|
|
2379
|
+
port?: pulumi.Input<number>;
|
|
2380
|
+
portOverride?: pulumi.Input<number>;
|
|
2381
|
+
schema?: pulumi.Input<string>;
|
|
2382
|
+
/**
|
|
2383
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2384
|
+
*/
|
|
2385
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2386
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2387
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2388
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2389
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2390
|
+
/**
|
|
2391
|
+
* Tags is a map of key, value pairs.
|
|
2392
|
+
*/
|
|
2393
|
+
tags?: pulumi.Input<{
|
|
2394
|
+
[key: string]: pulumi.Input<string>;
|
|
2395
|
+
}>;
|
|
2396
|
+
username?: pulumi.Input<string>;
|
|
2397
|
+
}
|
|
2398
|
+
export interface ResourceSsh {
|
|
2399
|
+
allowDeprecatedKeyExchanges?: pulumi.Input<boolean>;
|
|
2400
|
+
/**
|
|
2401
|
+
* Bind interface
|
|
2402
|
+
*/
|
|
2403
|
+
bindInterface?: pulumi.Input<string>;
|
|
2404
|
+
/**
|
|
2405
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2406
|
+
*/
|
|
2407
|
+
egressFilter?: pulumi.Input<string>;
|
|
2408
|
+
hostname: pulumi.Input<string>;
|
|
2409
|
+
keyType?: pulumi.Input<string>;
|
|
2410
|
+
/**
|
|
2411
|
+
* Unique human-readable name of the Resource.
|
|
2412
|
+
*/
|
|
2413
|
+
name: pulumi.Input<string>;
|
|
2414
|
+
port: pulumi.Input<number>;
|
|
2415
|
+
portForwarding?: pulumi.Input<boolean>;
|
|
2416
|
+
portOverride?: pulumi.Input<number>;
|
|
2417
|
+
/**
|
|
2418
|
+
* * ssh_cert:
|
|
2419
|
+
*/
|
|
2420
|
+
publicKey?: pulumi.Input<string>;
|
|
2421
|
+
/**
|
|
2422
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2423
|
+
*/
|
|
2424
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2425
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2426
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2427
|
+
/**
|
|
2428
|
+
* Tags is a map of key, value pairs.
|
|
2429
|
+
*/
|
|
2430
|
+
tags?: pulumi.Input<{
|
|
2431
|
+
[key: string]: pulumi.Input<string>;
|
|
2432
|
+
}>;
|
|
2433
|
+
username?: pulumi.Input<string>;
|
|
2434
|
+
}
|
|
2435
|
+
export interface ResourceSshCert {
|
|
2436
|
+
allowDeprecatedKeyExchanges?: pulumi.Input<boolean>;
|
|
2437
|
+
/**
|
|
2438
|
+
* Bind interface
|
|
2439
|
+
*/
|
|
2440
|
+
bindInterface?: pulumi.Input<string>;
|
|
2441
|
+
/**
|
|
2442
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2443
|
+
*/
|
|
2444
|
+
egressFilter?: pulumi.Input<string>;
|
|
2445
|
+
hostname: pulumi.Input<string>;
|
|
2446
|
+
keyType?: pulumi.Input<string>;
|
|
2447
|
+
/**
|
|
2448
|
+
* Unique human-readable name of the Resource.
|
|
2449
|
+
*/
|
|
2450
|
+
name: pulumi.Input<string>;
|
|
2451
|
+
port: pulumi.Input<number>;
|
|
2452
|
+
portForwarding?: pulumi.Input<boolean>;
|
|
2453
|
+
portOverride?: pulumi.Input<number>;
|
|
2454
|
+
remoteIdentityGroupId?: pulumi.Input<string>;
|
|
2455
|
+
remoteIdentityHealthcheckUsername?: pulumi.Input<string>;
|
|
2456
|
+
/**
|
|
2457
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2458
|
+
*/
|
|
2459
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2460
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2461
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2462
|
+
/**
|
|
2463
|
+
* Tags is a map of key, value pairs.
|
|
2464
|
+
*/
|
|
2465
|
+
tags?: pulumi.Input<{
|
|
2466
|
+
[key: string]: pulumi.Input<string>;
|
|
2467
|
+
}>;
|
|
2468
|
+
username?: pulumi.Input<string>;
|
|
2469
|
+
}
|
|
2470
|
+
export interface ResourceSshCustomerKey {
|
|
2471
|
+
allowDeprecatedKeyExchanges?: pulumi.Input<boolean>;
|
|
2472
|
+
/**
|
|
2473
|
+
* Bind interface
|
|
2474
|
+
*/
|
|
2475
|
+
bindInterface?: pulumi.Input<string>;
|
|
2476
|
+
/**
|
|
2477
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2478
|
+
*/
|
|
2479
|
+
egressFilter?: pulumi.Input<string>;
|
|
2480
|
+
hostname: pulumi.Input<string>;
|
|
2481
|
+
/**
|
|
2482
|
+
* Unique human-readable name of the Resource.
|
|
2483
|
+
*/
|
|
2484
|
+
name: pulumi.Input<string>;
|
|
2485
|
+
port: pulumi.Input<number>;
|
|
2486
|
+
portForwarding?: pulumi.Input<boolean>;
|
|
2487
|
+
portOverride?: pulumi.Input<number>;
|
|
2488
|
+
privateKey?: pulumi.Input<string>;
|
|
2489
|
+
/**
|
|
2490
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2491
|
+
*/
|
|
2492
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2493
|
+
secretStorePrivateKeyKey?: pulumi.Input<string>;
|
|
2494
|
+
secretStorePrivateKeyPath?: pulumi.Input<string>;
|
|
2495
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2496
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2497
|
+
/**
|
|
2498
|
+
* Tags is a map of key, value pairs.
|
|
2499
|
+
*/
|
|
2500
|
+
tags?: pulumi.Input<{
|
|
2501
|
+
[key: string]: pulumi.Input<string>;
|
|
2502
|
+
}>;
|
|
2503
|
+
username?: pulumi.Input<string>;
|
|
2504
|
+
}
|
|
2505
|
+
export interface ResourceSybase {
|
|
2506
|
+
/**
|
|
2507
|
+
* Bind interface
|
|
2508
|
+
*/
|
|
2509
|
+
bindInterface?: pulumi.Input<string>;
|
|
2510
|
+
/**
|
|
2511
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2512
|
+
*/
|
|
2513
|
+
egressFilter?: pulumi.Input<string>;
|
|
2514
|
+
hostname: pulumi.Input<string>;
|
|
2515
|
+
/**
|
|
2516
|
+
* Unique human-readable name of the Resource.
|
|
2517
|
+
*/
|
|
2518
|
+
name: pulumi.Input<string>;
|
|
2519
|
+
password?: pulumi.Input<string>;
|
|
2520
|
+
port?: pulumi.Input<number>;
|
|
2521
|
+
portOverride?: pulumi.Input<number>;
|
|
2522
|
+
/**
|
|
2523
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2524
|
+
*/
|
|
2525
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2526
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2527
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2528
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2529
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2530
|
+
/**
|
|
2531
|
+
* Tags is a map of key, value pairs.
|
|
2532
|
+
*/
|
|
2533
|
+
tags?: pulumi.Input<{
|
|
2534
|
+
[key: string]: pulumi.Input<string>;
|
|
2535
|
+
}>;
|
|
2536
|
+
username?: pulumi.Input<string>;
|
|
2537
|
+
}
|
|
2538
|
+
export interface ResourceSybaseIq {
|
|
2539
|
+
/**
|
|
2540
|
+
* Bind interface
|
|
2541
|
+
*/
|
|
2542
|
+
bindInterface?: pulumi.Input<string>;
|
|
2543
|
+
/**
|
|
2544
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2545
|
+
*/
|
|
2546
|
+
egressFilter?: pulumi.Input<string>;
|
|
2547
|
+
hostname: pulumi.Input<string>;
|
|
2548
|
+
/**
|
|
2549
|
+
* Unique human-readable name of the Resource.
|
|
2550
|
+
*/
|
|
2551
|
+
name: pulumi.Input<string>;
|
|
2552
|
+
password?: pulumi.Input<string>;
|
|
2553
|
+
port?: pulumi.Input<number>;
|
|
2554
|
+
portOverride?: pulumi.Input<number>;
|
|
2555
|
+
/**
|
|
2556
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2557
|
+
*/
|
|
2558
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2559
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2560
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2561
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2562
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2563
|
+
/**
|
|
2564
|
+
* Tags is a map of key, value pairs.
|
|
2565
|
+
*/
|
|
2566
|
+
tags?: pulumi.Input<{
|
|
2567
|
+
[key: string]: pulumi.Input<string>;
|
|
2568
|
+
}>;
|
|
2569
|
+
username?: pulumi.Input<string>;
|
|
2570
|
+
}
|
|
2571
|
+
export interface ResourceTeradata {
|
|
2572
|
+
/**
|
|
2573
|
+
* Bind interface
|
|
2574
|
+
*/
|
|
2575
|
+
bindInterface?: pulumi.Input<string>;
|
|
2576
|
+
/**
|
|
2577
|
+
* A filter applied to the routing logic to pin datasource to nodes.
|
|
2578
|
+
*/
|
|
2579
|
+
egressFilter?: pulumi.Input<string>;
|
|
2580
|
+
hostname: pulumi.Input<string>;
|
|
2581
|
+
/**
|
|
2582
|
+
* Unique human-readable name of the Resource.
|
|
2583
|
+
*/
|
|
2584
|
+
name: pulumi.Input<string>;
|
|
2585
|
+
password?: pulumi.Input<string>;
|
|
2586
|
+
port?: pulumi.Input<number>;
|
|
2587
|
+
portOverride?: pulumi.Input<number>;
|
|
2588
|
+
/**
|
|
2589
|
+
* ID of the secret store containing credentials for this resource, if any.
|
|
2590
|
+
*/
|
|
2591
|
+
secretStoreId?: pulumi.Input<string>;
|
|
2592
|
+
secretStorePasswordKey?: pulumi.Input<string>;
|
|
2593
|
+
secretStorePasswordPath?: pulumi.Input<string>;
|
|
2594
|
+
secretStoreUsernameKey?: pulumi.Input<string>;
|
|
2595
|
+
secretStoreUsernamePath?: pulumi.Input<string>;
|
|
2596
|
+
/**
|
|
2597
|
+
* Tags is a map of key, value pairs.
|
|
2598
|
+
*/
|
|
2599
|
+
tags?: pulumi.Input<{
|
|
2600
|
+
[key: string]: pulumi.Input<string>;
|
|
2601
|
+
}>;
|
|
2602
|
+
username?: pulumi.Input<string>;
|
|
2603
|
+
}
|
|
2604
|
+
export interface SecretStoreAws {
|
|
2605
|
+
/**
|
|
2606
|
+
* Unique human-readable name of the SecretStore.
|
|
2607
|
+
*/
|
|
2608
|
+
name: pulumi.Input<string>;
|
|
2609
|
+
region: pulumi.Input<string>;
|
|
2610
|
+
/**
|
|
2611
|
+
* Tags is a map of key, value pairs.
|
|
2612
|
+
*/
|
|
2613
|
+
tags?: pulumi.Input<{
|
|
2614
|
+
[key: string]: pulumi.Input<string>;
|
|
2615
|
+
}>;
|
|
2616
|
+
}
|
|
2617
|
+
export interface SecretStoreAzureStore {
|
|
2618
|
+
/**
|
|
2619
|
+
* Unique human-readable name of the SecretStore.
|
|
2620
|
+
*/
|
|
2621
|
+
name: pulumi.Input<string>;
|
|
2622
|
+
/**
|
|
2623
|
+
* Tags is a map of key, value pairs.
|
|
2624
|
+
*/
|
|
2625
|
+
tags?: pulumi.Input<{
|
|
2626
|
+
[key: string]: pulumi.Input<string>;
|
|
2627
|
+
}>;
|
|
2628
|
+
/**
|
|
2629
|
+
* * gcp_store:
|
|
2630
|
+
*/
|
|
2631
|
+
vaultUri: pulumi.Input<string>;
|
|
2632
|
+
}
|
|
2633
|
+
export interface SecretStoreGcpStore {
|
|
2634
|
+
/**
|
|
2635
|
+
* Unique human-readable name of the SecretStore.
|
|
2636
|
+
*/
|
|
2637
|
+
name: pulumi.Input<string>;
|
|
2638
|
+
projectId: pulumi.Input<string>;
|
|
2639
|
+
/**
|
|
2640
|
+
* Tags is a map of key, value pairs.
|
|
2641
|
+
*/
|
|
2642
|
+
tags?: pulumi.Input<{
|
|
2643
|
+
[key: string]: pulumi.Input<string>;
|
|
2644
|
+
}>;
|
|
2645
|
+
}
|
|
2646
|
+
export interface SecretStoreVaultApprole {
|
|
2647
|
+
/**
|
|
2648
|
+
* Unique human-readable name of the SecretStore.
|
|
2649
|
+
*/
|
|
2650
|
+
name: pulumi.Input<string>;
|
|
2651
|
+
namespace?: pulumi.Input<string>;
|
|
2652
|
+
serverAddress: pulumi.Input<string>;
|
|
2653
|
+
/**
|
|
2654
|
+
* Tags is a map of key, value pairs.
|
|
2655
|
+
*/
|
|
2656
|
+
tags?: pulumi.Input<{
|
|
2657
|
+
[key: string]: pulumi.Input<string>;
|
|
2658
|
+
}>;
|
|
2659
|
+
}
|
|
2660
|
+
export interface SecretStoreVaultTls {
|
|
2661
|
+
caCertPath?: pulumi.Input<string>;
|
|
2662
|
+
clientCertPath: pulumi.Input<string>;
|
|
2663
|
+
clientKeyPath: pulumi.Input<string>;
|
|
2664
|
+
/**
|
|
2665
|
+
* Unique human-readable name of the SecretStore.
|
|
2666
|
+
*/
|
|
2667
|
+
name: pulumi.Input<string>;
|
|
2668
|
+
namespace?: pulumi.Input<string>;
|
|
2669
|
+
serverAddress: pulumi.Input<string>;
|
|
2670
|
+
/**
|
|
2671
|
+
* Tags is a map of key, value pairs.
|
|
2672
|
+
*/
|
|
2673
|
+
tags?: pulumi.Input<{
|
|
2674
|
+
[key: string]: pulumi.Input<string>;
|
|
2675
|
+
}>;
|
|
2676
|
+
}
|
|
2677
|
+
export interface SecretStoreVaultToken {
|
|
2678
|
+
/**
|
|
2679
|
+
* Unique human-readable name of the SecretStore.
|
|
2680
|
+
*/
|
|
2681
|
+
name: pulumi.Input<string>;
|
|
2682
|
+
namespace?: pulumi.Input<string>;
|
|
2683
|
+
serverAddress: pulumi.Input<string>;
|
|
2684
|
+
/**
|
|
2685
|
+
* Tags is a map of key, value pairs.
|
|
2686
|
+
*/
|
|
2687
|
+
tags?: pulumi.Input<{
|
|
2688
|
+
[key: string]: pulumi.Input<string>;
|
|
2689
|
+
}>;
|
|
2690
|
+
}
|