@ibm-cloud/secrets-manager 0.1.1 → 1.0.3
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/{readme.md → README.md} +6 -8
- package/auth/index.d.ts +1 -1
- package/lib/common.js +1 -1
- package/lib/common.js.map +1 -1
- package/package.json +20 -19
- package/secrets-manager/v1.d.ts +1682 -347
- package/secrets-manager/v1.js +877 -338
- package/secrets-manager/v1.js.map +1 -1
package/secrets-manager/v1.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
/**
|
|
3
|
-
* (C) Copyright IBM Corp.
|
|
3
|
+
* (C) Copyright IBM Corp. 2022.
|
|
4
4
|
*
|
|
5
5
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
6
6
|
* you may not use this file except in compliance with the License.
|
|
@@ -27,16 +27,30 @@ var __extends = (this && this.__extends) || (function () {
|
|
|
27
27
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
28
28
|
};
|
|
29
29
|
})();
|
|
30
|
+
var __assign = (this && this.__assign) || function () {
|
|
31
|
+
__assign = Object.assign || function(t) {
|
|
32
|
+
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
33
|
+
s = arguments[i];
|
|
34
|
+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
35
|
+
t[p] = s[p];
|
|
36
|
+
}
|
|
37
|
+
return t;
|
|
38
|
+
};
|
|
39
|
+
return __assign.apply(this, arguments);
|
|
40
|
+
};
|
|
30
41
|
/**
|
|
31
|
-
* IBM OpenAPI SDK Code Generator Version: 3.
|
|
42
|
+
* IBM OpenAPI SDK Code Generator Version: 3.44.0-98838c07-20220128-151531
|
|
32
43
|
*/
|
|
33
44
|
var extend = require("extend");
|
|
34
45
|
var ibm_cloud_sdk_core_1 = require("ibm-cloud-sdk-core");
|
|
35
46
|
var common_1 = require("../lib/common");
|
|
36
47
|
/**
|
|
37
48
|
* With IBM Cloud® Secrets Manager, you can create, lease, and centrally manage secrets that are used in IBM Cloud
|
|
38
|
-
* services or your custom-built applications. Secrets are stored in a dedicated instance of Secrets Manager,
|
|
39
|
-
* open source HashiCorp Vault.
|
|
49
|
+
* services or your custom-built applications. Secrets are stored in a dedicated instance of Secrets Manager, which is
|
|
50
|
+
* built on open source HashiCorp Vault.
|
|
51
|
+
*
|
|
52
|
+
* API Version: 1.0.0
|
|
53
|
+
* See: https://cloud.ibm.com/docs/secrets-manager
|
|
40
54
|
*/
|
|
41
55
|
var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
42
56
|
__extends(SecretsManagerV1, _super);
|
|
@@ -89,183 +103,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
89
103
|
}
|
|
90
104
|
return service;
|
|
91
105
|
};
|
|
92
|
-
/*************************
|
|
93
|
-
* config
|
|
94
|
-
************************/
|
|
95
|
-
/**
|
|
96
|
-
* Configure secrets of a given type.
|
|
97
|
-
*
|
|
98
|
-
* Updates the configuration for the given secret type.
|
|
99
|
-
*
|
|
100
|
-
* @param {Object} params - The parameters to send to the service.
|
|
101
|
-
* @param {string} params.secretType - The secret type.
|
|
102
|
-
* @param {EngineConfigOneOf} params.engineConfigOneOf - The base request for setting secret engine configuration.
|
|
103
|
-
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
104
|
-
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.Empty>>}
|
|
105
|
-
*/
|
|
106
|
-
SecretsManagerV1.prototype.putConfig = function (params) {
|
|
107
|
-
var _params = Object.assign({}, params);
|
|
108
|
-
var requiredParams = ['secretType', 'engineConfigOneOf'];
|
|
109
|
-
var missingParams = ibm_cloud_sdk_core_1.getMissingParams(_params, requiredParams);
|
|
110
|
-
if (missingParams) {
|
|
111
|
-
return Promise.reject(missingParams);
|
|
112
|
-
}
|
|
113
|
-
var body = _params.engineConfigOneOf;
|
|
114
|
-
var path = {
|
|
115
|
-
'secret_type': _params.secretType
|
|
116
|
-
};
|
|
117
|
-
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'putConfig');
|
|
118
|
-
var parameters = {
|
|
119
|
-
options: {
|
|
120
|
-
url: '/api/v1/config/{secret_type}',
|
|
121
|
-
method: 'PUT',
|
|
122
|
-
body: body,
|
|
123
|
-
path: path,
|
|
124
|
-
},
|
|
125
|
-
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
126
|
-
headers: extend(true, sdkHeaders, {
|
|
127
|
-
'Content-Type': 'application/json',
|
|
128
|
-
}, _params.headers),
|
|
129
|
-
}),
|
|
130
|
-
};
|
|
131
|
-
return this.createRequest(parameters);
|
|
132
|
-
};
|
|
133
|
-
;
|
|
134
|
-
/**
|
|
135
|
-
* Get the configuration for a secret type.
|
|
136
|
-
*
|
|
137
|
-
* Retrieves the configuration that is associated with the given secret type.
|
|
138
|
-
*
|
|
139
|
-
* @param {Object} params - The parameters to send to the service.
|
|
140
|
-
* @param {string} params.secretType - The secret type.
|
|
141
|
-
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
142
|
-
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetConfig>>}
|
|
143
|
-
*/
|
|
144
|
-
SecretsManagerV1.prototype.getConfig = function (params) {
|
|
145
|
-
var _params = Object.assign({}, params);
|
|
146
|
-
var requiredParams = ['secretType'];
|
|
147
|
-
var missingParams = ibm_cloud_sdk_core_1.getMissingParams(_params, requiredParams);
|
|
148
|
-
if (missingParams) {
|
|
149
|
-
return Promise.reject(missingParams);
|
|
150
|
-
}
|
|
151
|
-
var path = {
|
|
152
|
-
'secret_type': _params.secretType
|
|
153
|
-
};
|
|
154
|
-
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getConfig');
|
|
155
|
-
var parameters = {
|
|
156
|
-
options: {
|
|
157
|
-
url: '/api/v1/config/{secret_type}',
|
|
158
|
-
method: 'GET',
|
|
159
|
-
path: path,
|
|
160
|
-
},
|
|
161
|
-
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
162
|
-
headers: extend(true, sdkHeaders, {
|
|
163
|
-
'Accept': 'application/json',
|
|
164
|
-
}, _params.headers),
|
|
165
|
-
}),
|
|
166
|
-
};
|
|
167
|
-
return this.createRequest(parameters);
|
|
168
|
-
};
|
|
169
|
-
;
|
|
170
|
-
/*************************
|
|
171
|
-
* policies
|
|
172
|
-
************************/
|
|
173
|
-
/**
|
|
174
|
-
* Set secret policies.
|
|
175
|
-
*
|
|
176
|
-
* Creates or updates one or more policies, such as an [automatic rotation
|
|
177
|
-
* policy](http://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-rotate-secrets#auto-rotate-secret), for the
|
|
178
|
-
* specified secret.
|
|
179
|
-
*
|
|
180
|
-
* @param {Object} params - The parameters to send to the service.
|
|
181
|
-
* @param {string} params.secretType - The secret type.
|
|
182
|
-
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
183
|
-
* @param {CollectionMetadata} params.metadata - The metadata that describes the resource array.
|
|
184
|
-
* @param {SecretPolicyRotation[]} params.resources - A collection of resources.
|
|
185
|
-
* @param {string} [params.policy] - The type of policy that is associated with the specified secret.
|
|
186
|
-
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
187
|
-
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretPoliciesOneOf>>}
|
|
188
|
-
*/
|
|
189
|
-
SecretsManagerV1.prototype.putPolicy = function (params) {
|
|
190
|
-
var _params = Object.assign({}, params);
|
|
191
|
-
var requiredParams = ['secretType', 'id', 'metadata', 'resources'];
|
|
192
|
-
var missingParams = ibm_cloud_sdk_core_1.getMissingParams(_params, requiredParams);
|
|
193
|
-
if (missingParams) {
|
|
194
|
-
return Promise.reject(missingParams);
|
|
195
|
-
}
|
|
196
|
-
var body = {
|
|
197
|
-
'metadata': _params.metadata,
|
|
198
|
-
'resources': _params.resources
|
|
199
|
-
};
|
|
200
|
-
var query = {
|
|
201
|
-
'policy': _params.policy
|
|
202
|
-
};
|
|
203
|
-
var path = {
|
|
204
|
-
'secret_type': _params.secretType,
|
|
205
|
-
'id': _params.id
|
|
206
|
-
};
|
|
207
|
-
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'putPolicy');
|
|
208
|
-
var parameters = {
|
|
209
|
-
options: {
|
|
210
|
-
url: '/api/v1/secrets/{secret_type}/{id}/policies',
|
|
211
|
-
method: 'PUT',
|
|
212
|
-
body: body,
|
|
213
|
-
qs: query,
|
|
214
|
-
path: path,
|
|
215
|
-
},
|
|
216
|
-
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
217
|
-
headers: extend(true, sdkHeaders, {
|
|
218
|
-
'Accept': 'application/json',
|
|
219
|
-
'Content-Type': 'application/json',
|
|
220
|
-
}, _params.headers),
|
|
221
|
-
}),
|
|
222
|
-
};
|
|
223
|
-
return this.createRequest(parameters);
|
|
224
|
-
};
|
|
225
|
-
;
|
|
226
|
-
/**
|
|
227
|
-
* List secret policies.
|
|
228
|
-
*
|
|
229
|
-
* Retrieves a list of policies that are associated with a specified secret.
|
|
230
|
-
*
|
|
231
|
-
* @param {Object} params - The parameters to send to the service.
|
|
232
|
-
* @param {string} params.secretType - The secret type.
|
|
233
|
-
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
234
|
-
* @param {string} [params.policy] - The type of policy that is associated with the specified secret.
|
|
235
|
-
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
236
|
-
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretPoliciesOneOf>>}
|
|
237
|
-
*/
|
|
238
|
-
SecretsManagerV1.prototype.getPolicy = function (params) {
|
|
239
|
-
var _params = Object.assign({}, params);
|
|
240
|
-
var requiredParams = ['secretType', 'id'];
|
|
241
|
-
var missingParams = ibm_cloud_sdk_core_1.getMissingParams(_params, requiredParams);
|
|
242
|
-
if (missingParams) {
|
|
243
|
-
return Promise.reject(missingParams);
|
|
244
|
-
}
|
|
245
|
-
var query = {
|
|
246
|
-
'policy': _params.policy
|
|
247
|
-
};
|
|
248
|
-
var path = {
|
|
249
|
-
'secret_type': _params.secretType,
|
|
250
|
-
'id': _params.id
|
|
251
|
-
};
|
|
252
|
-
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getPolicy');
|
|
253
|
-
var parameters = {
|
|
254
|
-
options: {
|
|
255
|
-
url: '/api/v1/secrets/{secret_type}/{id}/policies',
|
|
256
|
-
method: 'GET',
|
|
257
|
-
qs: query,
|
|
258
|
-
path: path,
|
|
259
|
-
},
|
|
260
|
-
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
261
|
-
headers: extend(true, sdkHeaders, {
|
|
262
|
-
'Accept': 'application/json',
|
|
263
|
-
}, _params.headers),
|
|
264
|
-
}),
|
|
265
|
-
};
|
|
266
|
-
return this.createRequest(parameters);
|
|
267
|
-
};
|
|
268
|
-
;
|
|
269
106
|
/*************************
|
|
270
107
|
* secretGroups
|
|
271
108
|
************************/
|
|
@@ -285,15 +122,16 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
285
122
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretGroupDef>>}
|
|
286
123
|
*/
|
|
287
124
|
SecretsManagerV1.prototype.createSecretGroup = function (params) {
|
|
288
|
-
var _params =
|
|
289
|
-
var
|
|
290
|
-
var
|
|
291
|
-
|
|
292
|
-
|
|
125
|
+
var _params = __assign({}, params);
|
|
126
|
+
var _requiredParams = ['metadata', 'resources'];
|
|
127
|
+
var _validParams = ['metadata', 'resources', 'headers'];
|
|
128
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
129
|
+
if (_validationErrors) {
|
|
130
|
+
return Promise.reject(_validationErrors);
|
|
293
131
|
}
|
|
294
132
|
var body = {
|
|
295
133
|
'metadata': _params.metadata,
|
|
296
|
-
'resources': _params.resources
|
|
134
|
+
'resources': _params.resources,
|
|
297
135
|
};
|
|
298
136
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'createSecretGroup');
|
|
299
137
|
var parameters = {
|
|
@@ -311,7 +149,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
311
149
|
};
|
|
312
150
|
return this.createRequest(parameters);
|
|
313
151
|
};
|
|
314
|
-
;
|
|
315
152
|
/**
|
|
316
153
|
* List secret groups.
|
|
317
154
|
*
|
|
@@ -322,7 +159,13 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
322
159
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretGroupDef>>}
|
|
323
160
|
*/
|
|
324
161
|
SecretsManagerV1.prototype.listSecretGroups = function (params) {
|
|
325
|
-
var _params =
|
|
162
|
+
var _params = __assign({}, params);
|
|
163
|
+
var _requiredParams = [];
|
|
164
|
+
var _validParams = ['headers'];
|
|
165
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
166
|
+
if (_validationErrors) {
|
|
167
|
+
return Promise.reject(_validationErrors);
|
|
168
|
+
}
|
|
326
169
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'listSecretGroups');
|
|
327
170
|
var parameters = {
|
|
328
171
|
options: {
|
|
@@ -337,7 +180,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
337
180
|
};
|
|
338
181
|
return this.createRequest(parameters);
|
|
339
182
|
};
|
|
340
|
-
;
|
|
341
183
|
/**
|
|
342
184
|
* Get a secret group.
|
|
343
185
|
*
|
|
@@ -349,14 +191,15 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
349
191
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretGroupDef>>}
|
|
350
192
|
*/
|
|
351
193
|
SecretsManagerV1.prototype.getSecretGroup = function (params) {
|
|
352
|
-
var _params =
|
|
353
|
-
var
|
|
354
|
-
var
|
|
355
|
-
|
|
356
|
-
|
|
194
|
+
var _params = __assign({}, params);
|
|
195
|
+
var _requiredParams = ['id'];
|
|
196
|
+
var _validParams = ['id', 'headers'];
|
|
197
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
198
|
+
if (_validationErrors) {
|
|
199
|
+
return Promise.reject(_validationErrors);
|
|
357
200
|
}
|
|
358
201
|
var path = {
|
|
359
|
-
'id': _params.id
|
|
202
|
+
'id': _params.id,
|
|
360
203
|
};
|
|
361
204
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getSecretGroup');
|
|
362
205
|
var parameters = {
|
|
@@ -373,7 +216,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
373
216
|
};
|
|
374
217
|
return this.createRequest(parameters);
|
|
375
218
|
};
|
|
376
|
-
;
|
|
377
219
|
/**
|
|
378
220
|
* Update a secret group.
|
|
379
221
|
*
|
|
@@ -387,18 +229,19 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
387
229
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretGroupDef>>}
|
|
388
230
|
*/
|
|
389
231
|
SecretsManagerV1.prototype.updateSecretGroupMetadata = function (params) {
|
|
390
|
-
var _params =
|
|
391
|
-
var
|
|
392
|
-
var
|
|
393
|
-
|
|
394
|
-
|
|
232
|
+
var _params = __assign({}, params);
|
|
233
|
+
var _requiredParams = ['id', 'metadata', 'resources'];
|
|
234
|
+
var _validParams = ['id', 'metadata', 'resources', 'headers'];
|
|
235
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
236
|
+
if (_validationErrors) {
|
|
237
|
+
return Promise.reject(_validationErrors);
|
|
395
238
|
}
|
|
396
239
|
var body = {
|
|
397
240
|
'metadata': _params.metadata,
|
|
398
|
-
'resources': _params.resources
|
|
241
|
+
'resources': _params.resources,
|
|
399
242
|
};
|
|
400
243
|
var path = {
|
|
401
|
-
'id': _params.id
|
|
244
|
+
'id': _params.id,
|
|
402
245
|
};
|
|
403
246
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'updateSecretGroupMetadata');
|
|
404
247
|
var parameters = {
|
|
@@ -417,7 +260,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
417
260
|
};
|
|
418
261
|
return this.createRequest(parameters);
|
|
419
262
|
};
|
|
420
|
-
;
|
|
421
263
|
/**
|
|
422
264
|
* Delete a secret group.
|
|
423
265
|
*
|
|
@@ -432,14 +274,15 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
432
274
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.Empty>>}
|
|
433
275
|
*/
|
|
434
276
|
SecretsManagerV1.prototype.deleteSecretGroup = function (params) {
|
|
435
|
-
var _params =
|
|
436
|
-
var
|
|
437
|
-
var
|
|
438
|
-
|
|
439
|
-
|
|
277
|
+
var _params = __assign({}, params);
|
|
278
|
+
var _requiredParams = ['id'];
|
|
279
|
+
var _validParams = ['id', 'headers'];
|
|
280
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
281
|
+
if (_validationErrors) {
|
|
282
|
+
return Promise.reject(_validationErrors);
|
|
440
283
|
}
|
|
441
284
|
var path = {
|
|
442
|
-
'id': _params.id
|
|
285
|
+
'id': _params.id,
|
|
443
286
|
};
|
|
444
287
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'deleteSecretGroup');
|
|
445
288
|
var parameters = {
|
|
@@ -454,20 +297,21 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
454
297
|
};
|
|
455
298
|
return this.createRequest(parameters);
|
|
456
299
|
};
|
|
457
|
-
;
|
|
458
300
|
/*************************
|
|
459
301
|
* secrets
|
|
460
302
|
************************/
|
|
461
303
|
/**
|
|
462
304
|
* Create a secret.
|
|
463
305
|
*
|
|
464
|
-
*
|
|
306
|
+
* Create a secret or import an existing value that you can use to access or authenticate to a protected resource.
|
|
465
307
|
*
|
|
466
|
-
*
|
|
467
|
-
*
|
|
308
|
+
* Use this method to either generate or import an existing secret, such as an arbitrary value or a TLS certificate,
|
|
309
|
+
* that you can manage in your Secrets Manager service instance. A successful request stores the secret in your
|
|
310
|
+
* dedicated instance based on the secret type and data that you specify. The response returns the ID value of the
|
|
311
|
+
* secret, along with other metadata.
|
|
468
312
|
*
|
|
469
313
|
* To learn more about the types of secrets that you can create with Secrets Manager, check out the
|
|
470
|
-
* [docs](https://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-secret
|
|
314
|
+
* [docs](https://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-what-is-secret).
|
|
471
315
|
*
|
|
472
316
|
* @param {Object} params - The parameters to send to the service.
|
|
473
317
|
* @param {string} params.secretType - The secret type.
|
|
@@ -477,18 +321,19 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
477
321
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.CreateSecret>>}
|
|
478
322
|
*/
|
|
479
323
|
SecretsManagerV1.prototype.createSecret = function (params) {
|
|
480
|
-
var _params =
|
|
481
|
-
var
|
|
482
|
-
var
|
|
483
|
-
|
|
484
|
-
|
|
324
|
+
var _params = __assign({}, params);
|
|
325
|
+
var _requiredParams = ['secretType', 'metadata', 'resources'];
|
|
326
|
+
var _validParams = ['secretType', 'metadata', 'resources', 'headers'];
|
|
327
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
328
|
+
if (_validationErrors) {
|
|
329
|
+
return Promise.reject(_validationErrors);
|
|
485
330
|
}
|
|
486
331
|
var body = {
|
|
487
332
|
'metadata': _params.metadata,
|
|
488
|
-
'resources': _params.resources
|
|
333
|
+
'resources': _params.resources,
|
|
489
334
|
};
|
|
490
335
|
var path = {
|
|
491
|
-
'secret_type': _params.secretType
|
|
336
|
+
'secret_type': _params.secretType,
|
|
492
337
|
};
|
|
493
338
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'createSecret');
|
|
494
339
|
var parameters = {
|
|
@@ -507,7 +352,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
507
352
|
};
|
|
508
353
|
return this.createRequest(parameters);
|
|
509
354
|
};
|
|
510
|
-
;
|
|
511
355
|
/**
|
|
512
356
|
* List secrets by type.
|
|
513
357
|
*
|
|
@@ -530,18 +374,19 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
530
374
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.ListSecrets>>}
|
|
531
375
|
*/
|
|
532
376
|
SecretsManagerV1.prototype.listSecrets = function (params) {
|
|
533
|
-
var _params =
|
|
534
|
-
var
|
|
535
|
-
var
|
|
536
|
-
|
|
537
|
-
|
|
377
|
+
var _params = __assign({}, params);
|
|
378
|
+
var _requiredParams = ['secretType'];
|
|
379
|
+
var _validParams = ['secretType', 'limit', 'offset', 'headers'];
|
|
380
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
381
|
+
if (_validationErrors) {
|
|
382
|
+
return Promise.reject(_validationErrors);
|
|
538
383
|
}
|
|
539
384
|
var query = {
|
|
540
385
|
'limit': _params.limit,
|
|
541
|
-
'offset': _params.offset
|
|
386
|
+
'offset': _params.offset,
|
|
542
387
|
};
|
|
543
388
|
var path = {
|
|
544
|
-
'secret_type': _params.secretType
|
|
389
|
+
'secret_type': _params.secretType,
|
|
545
390
|
};
|
|
546
391
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'listSecrets');
|
|
547
392
|
var parameters = {
|
|
@@ -559,7 +404,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
559
404
|
};
|
|
560
405
|
return this.createRequest(parameters);
|
|
561
406
|
};
|
|
562
|
-
;
|
|
563
407
|
/**
|
|
564
408
|
* List all secrets.
|
|
565
409
|
*
|
|
@@ -597,13 +441,19 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
597
441
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.ListSecrets>>}
|
|
598
442
|
*/
|
|
599
443
|
SecretsManagerV1.prototype.listAllSecrets = function (params) {
|
|
600
|
-
var _params =
|
|
444
|
+
var _params = __assign({}, params);
|
|
445
|
+
var _requiredParams = [];
|
|
446
|
+
var _validParams = ['limit', 'offset', 'search', 'sortBy', 'groups', 'headers'];
|
|
447
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
448
|
+
if (_validationErrors) {
|
|
449
|
+
return Promise.reject(_validationErrors);
|
|
450
|
+
}
|
|
601
451
|
var query = {
|
|
602
452
|
'limit': _params.limit,
|
|
603
453
|
'offset': _params.offset,
|
|
604
454
|
'search': _params.search,
|
|
605
455
|
'sort_by': _params.sortBy,
|
|
606
|
-
'groups': _params.groups
|
|
456
|
+
'groups': _params.groups,
|
|
607
457
|
};
|
|
608
458
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'listAllSecrets');
|
|
609
459
|
var parameters = {
|
|
@@ -620,11 +470,10 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
620
470
|
};
|
|
621
471
|
return this.createRequest(parameters);
|
|
622
472
|
};
|
|
623
|
-
;
|
|
624
473
|
/**
|
|
625
474
|
* Get a secret.
|
|
626
475
|
*
|
|
627
|
-
*
|
|
476
|
+
* Get a secret and its details by specifying the ID of the secret.
|
|
628
477
|
*
|
|
629
478
|
* A successful request returns the secret data that is associated with your secret, along with other metadata. To
|
|
630
479
|
* view only the details of a specified secret without retrieving its value, use the [Get secret
|
|
@@ -637,15 +486,16 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
637
486
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecret>>}
|
|
638
487
|
*/
|
|
639
488
|
SecretsManagerV1.prototype.getSecret = function (params) {
|
|
640
|
-
var _params =
|
|
641
|
-
var
|
|
642
|
-
var
|
|
643
|
-
|
|
644
|
-
|
|
489
|
+
var _params = __assign({}, params);
|
|
490
|
+
var _requiredParams = ['secretType', 'id'];
|
|
491
|
+
var _validParams = ['secretType', 'id', 'headers'];
|
|
492
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
493
|
+
if (_validationErrors) {
|
|
494
|
+
return Promise.reject(_validationErrors);
|
|
645
495
|
}
|
|
646
496
|
var path = {
|
|
647
497
|
'secret_type': _params.secretType,
|
|
648
|
-
'id': _params.id
|
|
498
|
+
'id': _params.id,
|
|
649
499
|
};
|
|
650
500
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getSecret');
|
|
651
501
|
var parameters = {
|
|
@@ -662,37 +512,38 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
662
512
|
};
|
|
663
513
|
return this.createRequest(parameters);
|
|
664
514
|
};
|
|
665
|
-
;
|
|
666
515
|
/**
|
|
667
516
|
* Invoke an action on a secret.
|
|
668
517
|
*
|
|
669
518
|
* Invokes an action on a specified secret. This method supports the following actions:
|
|
670
519
|
*
|
|
671
|
-
* - `rotate`: Replace the value of
|
|
520
|
+
* - `rotate`: Replace the value of a secret.
|
|
521
|
+
* - `restore`: Restore a previous version of an `iam_credentials` secret.
|
|
672
522
|
* - `delete_credentials`: Delete the API key that is associated with an `iam_credentials` secret.
|
|
673
523
|
*
|
|
674
524
|
* @param {Object} params - The parameters to send to the service.
|
|
675
525
|
* @param {string} params.secretType - The secret type.
|
|
676
526
|
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
677
527
|
* @param {string} params.action - The action to perform on the specified secret.
|
|
678
|
-
* @param {
|
|
528
|
+
* @param {SecretAction} [params.secretAction] - The properties to update for the secret.
|
|
679
529
|
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
680
530
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecret>>}
|
|
681
531
|
*/
|
|
682
532
|
SecretsManagerV1.prototype.updateSecret = function (params) {
|
|
683
|
-
var _params =
|
|
684
|
-
var
|
|
685
|
-
var
|
|
686
|
-
|
|
687
|
-
|
|
533
|
+
var _params = __assign({}, params);
|
|
534
|
+
var _requiredParams = ['secretType', 'id', 'action'];
|
|
535
|
+
var _validParams = ['secretType', 'id', 'action', 'secretAction', 'headers'];
|
|
536
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
537
|
+
if (_validationErrors) {
|
|
538
|
+
return Promise.reject(_validationErrors);
|
|
688
539
|
}
|
|
689
|
-
var body = _params.
|
|
540
|
+
var body = _params.secretAction;
|
|
690
541
|
var query = {
|
|
691
|
-
'action': _params.action
|
|
542
|
+
'action': _params.action,
|
|
692
543
|
};
|
|
693
544
|
var path = {
|
|
694
545
|
'secret_type': _params.secretType,
|
|
695
|
-
'id': _params.id
|
|
546
|
+
'id': _params.id,
|
|
696
547
|
};
|
|
697
548
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'updateSecret');
|
|
698
549
|
var parameters = {
|
|
@@ -712,7 +563,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
712
563
|
};
|
|
713
564
|
return this.createRequest(parameters);
|
|
714
565
|
};
|
|
715
|
-
;
|
|
716
566
|
/**
|
|
717
567
|
* Delete a secret.
|
|
718
568
|
*
|
|
@@ -725,15 +575,16 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
725
575
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.Empty>>}
|
|
726
576
|
*/
|
|
727
577
|
SecretsManagerV1.prototype.deleteSecret = function (params) {
|
|
728
|
-
var _params =
|
|
729
|
-
var
|
|
730
|
-
var
|
|
731
|
-
|
|
732
|
-
|
|
578
|
+
var _params = __assign({}, params);
|
|
579
|
+
var _requiredParams = ['secretType', 'id'];
|
|
580
|
+
var _validParams = ['secretType', 'id', 'headers'];
|
|
581
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
582
|
+
if (_validationErrors) {
|
|
583
|
+
return Promise.reject(_validationErrors);
|
|
733
584
|
}
|
|
734
585
|
var path = {
|
|
735
586
|
'secret_type': _params.secretType,
|
|
736
|
-
'id': _params.id
|
|
587
|
+
'id': _params.id,
|
|
737
588
|
};
|
|
738
589
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'deleteSecret');
|
|
739
590
|
var parameters = {
|
|
@@ -748,14 +599,146 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
748
599
|
};
|
|
749
600
|
return this.createRequest(parameters);
|
|
750
601
|
};
|
|
751
|
-
|
|
602
|
+
/**
|
|
603
|
+
* List versions of a secret.
|
|
604
|
+
*
|
|
605
|
+
* Retrieves a list of the versions of a secret.
|
|
606
|
+
*
|
|
607
|
+
* A successful request returns the list of the versions along with the metadata of each version.
|
|
608
|
+
*
|
|
609
|
+
* @param {Object} params - The parameters to send to the service.
|
|
610
|
+
* @param {string} params.secretType - The secret type.
|
|
611
|
+
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
612
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
613
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.ListSecretVersions>>}
|
|
614
|
+
*/
|
|
615
|
+
SecretsManagerV1.prototype.listSecretVersions = function (params) {
|
|
616
|
+
var _params = __assign({}, params);
|
|
617
|
+
var _requiredParams = ['secretType', 'id'];
|
|
618
|
+
var _validParams = ['secretType', 'id', 'headers'];
|
|
619
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
620
|
+
if (_validationErrors) {
|
|
621
|
+
return Promise.reject(_validationErrors);
|
|
622
|
+
}
|
|
623
|
+
var path = {
|
|
624
|
+
'secret_type': _params.secretType,
|
|
625
|
+
'id': _params.id,
|
|
626
|
+
};
|
|
627
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'listSecretVersions');
|
|
628
|
+
var parameters = {
|
|
629
|
+
options: {
|
|
630
|
+
url: '/api/v1/secrets/{secret_type}/{id}/versions',
|
|
631
|
+
method: 'GET',
|
|
632
|
+
path: path,
|
|
633
|
+
},
|
|
634
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
635
|
+
headers: extend(true, sdkHeaders, {
|
|
636
|
+
'Accept': 'application/json',
|
|
637
|
+
}, _params.headers),
|
|
638
|
+
}),
|
|
639
|
+
};
|
|
640
|
+
return this.createRequest(parameters);
|
|
641
|
+
};
|
|
642
|
+
/**
|
|
643
|
+
* Get a version of a secret.
|
|
644
|
+
*
|
|
645
|
+
* Retrieves a version of a secret by specifying the ID of the version or the alias `previous`.
|
|
646
|
+
*
|
|
647
|
+
* A successful request returns the secret data that is associated with the specified version of your secret, along
|
|
648
|
+
* with other metadata.
|
|
649
|
+
*
|
|
650
|
+
* @param {Object} params - The parameters to send to the service.
|
|
651
|
+
* @param {string} params.secretType - The secret type.
|
|
652
|
+
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
653
|
+
* @param {string} params.versionId - The v4 UUID that uniquely identifies the secret version. You can also use
|
|
654
|
+
* `previous` to retrieve the previous version.
|
|
655
|
+
*
|
|
656
|
+
* **Note:** To find the version ID of a secret, use the [Get secret metadata](#get-secret-metadata) method and check
|
|
657
|
+
* the response details.
|
|
658
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
659
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretVersion>>}
|
|
660
|
+
*/
|
|
661
|
+
SecretsManagerV1.prototype.getSecretVersion = function (params) {
|
|
662
|
+
var _params = __assign({}, params);
|
|
663
|
+
var _requiredParams = ['secretType', 'id', 'versionId'];
|
|
664
|
+
var _validParams = ['secretType', 'id', 'versionId', 'headers'];
|
|
665
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
666
|
+
if (_validationErrors) {
|
|
667
|
+
return Promise.reject(_validationErrors);
|
|
668
|
+
}
|
|
669
|
+
var path = {
|
|
670
|
+
'secret_type': _params.secretType,
|
|
671
|
+
'id': _params.id,
|
|
672
|
+
'version_id': _params.versionId,
|
|
673
|
+
};
|
|
674
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getSecretVersion');
|
|
675
|
+
var parameters = {
|
|
676
|
+
options: {
|
|
677
|
+
url: '/api/v1/secrets/{secret_type}/{id}/versions/{version_id}',
|
|
678
|
+
method: 'GET',
|
|
679
|
+
path: path,
|
|
680
|
+
},
|
|
681
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
682
|
+
headers: extend(true, sdkHeaders, {
|
|
683
|
+
'Accept': 'application/json',
|
|
684
|
+
}, _params.headers),
|
|
685
|
+
}),
|
|
686
|
+
};
|
|
687
|
+
return this.createRequest(parameters);
|
|
688
|
+
};
|
|
689
|
+
/**
|
|
690
|
+
* Get secret version metadata.
|
|
691
|
+
*
|
|
692
|
+
* Retrieves secret version metadata by specifying the ID of the version or the alias `previous`.
|
|
693
|
+
*
|
|
694
|
+
* A successful request returns the metadata that is associated with the specified version of your secret.
|
|
695
|
+
*
|
|
696
|
+
* @param {Object} params - The parameters to send to the service.
|
|
697
|
+
* @param {string} params.secretType - The secret type.
|
|
698
|
+
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
699
|
+
* @param {string} params.versionId - The v4 UUID that uniquely identifies the secret version. You can also use
|
|
700
|
+
* `previous` to retrieve the previous version.
|
|
701
|
+
*
|
|
702
|
+
* **Note:** To find the version ID of a secret, use the [Get secret metadata](#get-secret-metadata) method and check
|
|
703
|
+
* the response details.
|
|
704
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
705
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretVersionMetadata>>}
|
|
706
|
+
*/
|
|
707
|
+
SecretsManagerV1.prototype.getSecretVersionMetadata = function (params) {
|
|
708
|
+
var _params = __assign({}, params);
|
|
709
|
+
var _requiredParams = ['secretType', 'id', 'versionId'];
|
|
710
|
+
var _validParams = ['secretType', 'id', 'versionId', 'headers'];
|
|
711
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
712
|
+
if (_validationErrors) {
|
|
713
|
+
return Promise.reject(_validationErrors);
|
|
714
|
+
}
|
|
715
|
+
var path = {
|
|
716
|
+
'secret_type': _params.secretType,
|
|
717
|
+
'id': _params.id,
|
|
718
|
+
'version_id': _params.versionId,
|
|
719
|
+
};
|
|
720
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getSecretVersionMetadata');
|
|
721
|
+
var parameters = {
|
|
722
|
+
options: {
|
|
723
|
+
url: '/api/v1/secrets/{secret_type}/{id}/versions/{version_id}/metadata',
|
|
724
|
+
method: 'GET',
|
|
725
|
+
path: path,
|
|
726
|
+
},
|
|
727
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
728
|
+
headers: extend(true, sdkHeaders, {
|
|
729
|
+
'Accept': 'application/json',
|
|
730
|
+
}, _params.headers),
|
|
731
|
+
}),
|
|
732
|
+
};
|
|
733
|
+
return this.createRequest(parameters);
|
|
734
|
+
};
|
|
752
735
|
/**
|
|
753
736
|
* Get secret metadata.
|
|
754
737
|
*
|
|
755
738
|
* Retrieves the details of a secret by specifying the ID.
|
|
756
739
|
*
|
|
757
740
|
* A successful request returns only metadata about the secret, such as its name and creation date. To retrieve the
|
|
758
|
-
* value of a secret, use the [Get a secret](#get-secret)
|
|
741
|
+
* value of a secret, use the [Get a secret](#get-secret) or [Get a version of a secret](#get-secret-version) methods.
|
|
759
742
|
*
|
|
760
743
|
* @param {Object} params - The parameters to send to the service.
|
|
761
744
|
* @param {string} params.secretType - The secret type.
|
|
@@ -764,15 +747,16 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
764
747
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretMetadataRequest>>}
|
|
765
748
|
*/
|
|
766
749
|
SecretsManagerV1.prototype.getSecretMetadata = function (params) {
|
|
767
|
-
var _params =
|
|
768
|
-
var
|
|
769
|
-
var
|
|
770
|
-
|
|
771
|
-
|
|
750
|
+
var _params = __assign({}, params);
|
|
751
|
+
var _requiredParams = ['secretType', 'id'];
|
|
752
|
+
var _validParams = ['secretType', 'id', 'headers'];
|
|
753
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
754
|
+
if (_validationErrors) {
|
|
755
|
+
return Promise.reject(_validationErrors);
|
|
772
756
|
}
|
|
773
757
|
var path = {
|
|
774
758
|
'secret_type': _params.secretType,
|
|
775
|
-
'id': _params.id
|
|
759
|
+
'id': _params.id,
|
|
776
760
|
};
|
|
777
761
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getSecretMetadata');
|
|
778
762
|
var parameters = {
|
|
@@ -789,7 +773,6 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
789
773
|
};
|
|
790
774
|
return this.createRequest(parameters);
|
|
791
775
|
};
|
|
792
|
-
;
|
|
793
776
|
/**
|
|
794
777
|
* Update secret metadata.
|
|
795
778
|
*
|
|
@@ -807,19 +790,20 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
807
790
|
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.SecretMetadataRequest>>}
|
|
808
791
|
*/
|
|
809
792
|
SecretsManagerV1.prototype.updateSecretMetadata = function (params) {
|
|
810
|
-
var _params =
|
|
811
|
-
var
|
|
812
|
-
var
|
|
813
|
-
|
|
814
|
-
|
|
793
|
+
var _params = __assign({}, params);
|
|
794
|
+
var _requiredParams = ['secretType', 'id', 'metadata', 'resources'];
|
|
795
|
+
var _validParams = ['secretType', 'id', 'metadata', 'resources', 'headers'];
|
|
796
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
797
|
+
if (_validationErrors) {
|
|
798
|
+
return Promise.reject(_validationErrors);
|
|
815
799
|
}
|
|
816
800
|
var body = {
|
|
817
801
|
'metadata': _params.metadata,
|
|
818
|
-
'resources': _params.resources
|
|
802
|
+
'resources': _params.resources,
|
|
819
803
|
};
|
|
820
804
|
var path = {
|
|
821
805
|
'secret_type': _params.secretType,
|
|
822
|
-
'id': _params.id
|
|
806
|
+
'id': _params.id,
|
|
823
807
|
};
|
|
824
808
|
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'updateSecretMetadata');
|
|
825
809
|
var parameters = {
|
|
@@ -838,61 +822,412 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
838
822
|
};
|
|
839
823
|
return this.createRequest(parameters);
|
|
840
824
|
};
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
var
|
|
864
|
-
(
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
var
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
}
|
|
895
|
-
|
|
825
|
+
/*************************
|
|
826
|
+
* policies
|
|
827
|
+
************************/
|
|
828
|
+
/**
|
|
829
|
+
* Set secret policies.
|
|
830
|
+
*
|
|
831
|
+
* Creates or updates one or more policies, such as an [automatic rotation
|
|
832
|
+
* policy](http://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-rotate-secrets#auto-rotate-secret), for the
|
|
833
|
+
* specified secret.
|
|
834
|
+
*
|
|
835
|
+
* @param {Object} params - The parameters to send to the service.
|
|
836
|
+
* @param {string} params.secretType - The secret type.
|
|
837
|
+
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
838
|
+
* @param {CollectionMetadata} params.metadata - The metadata that describes the resource array.
|
|
839
|
+
* @param {SecretPolicyRotation[]} params.resources - A collection of resources.
|
|
840
|
+
* @param {string} [params.policy] - The type of policy that is associated with the specified secret.
|
|
841
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
842
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretPolicies>>}
|
|
843
|
+
*/
|
|
844
|
+
SecretsManagerV1.prototype.putPolicy = function (params) {
|
|
845
|
+
var _params = __assign({}, params);
|
|
846
|
+
var _requiredParams = ['secretType', 'id', 'metadata', 'resources'];
|
|
847
|
+
var _validParams = ['secretType', 'id', 'metadata', 'resources', 'policy', 'headers'];
|
|
848
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
849
|
+
if (_validationErrors) {
|
|
850
|
+
return Promise.reject(_validationErrors);
|
|
851
|
+
}
|
|
852
|
+
var body = {
|
|
853
|
+
'metadata': _params.metadata,
|
|
854
|
+
'resources': _params.resources,
|
|
855
|
+
};
|
|
856
|
+
var query = {
|
|
857
|
+
'policy': _params.policy,
|
|
858
|
+
};
|
|
859
|
+
var path = {
|
|
860
|
+
'secret_type': _params.secretType,
|
|
861
|
+
'id': _params.id,
|
|
862
|
+
};
|
|
863
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'putPolicy');
|
|
864
|
+
var parameters = {
|
|
865
|
+
options: {
|
|
866
|
+
url: '/api/v1/secrets/{secret_type}/{id}/policies',
|
|
867
|
+
method: 'PUT',
|
|
868
|
+
body: body,
|
|
869
|
+
qs: query,
|
|
870
|
+
path: path,
|
|
871
|
+
},
|
|
872
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
873
|
+
headers: extend(true, sdkHeaders, {
|
|
874
|
+
'Accept': 'application/json',
|
|
875
|
+
'Content-Type': 'application/json',
|
|
876
|
+
}, _params.headers),
|
|
877
|
+
}),
|
|
878
|
+
};
|
|
879
|
+
return this.createRequest(parameters);
|
|
880
|
+
};
|
|
881
|
+
/**
|
|
882
|
+
* List secret policies.
|
|
883
|
+
*
|
|
884
|
+
* Retrieves a list of policies that are associated with a specified secret.
|
|
885
|
+
*
|
|
886
|
+
* @param {Object} params - The parameters to send to the service.
|
|
887
|
+
* @param {string} params.secretType - The secret type.
|
|
888
|
+
* @param {string} params.id - The v4 UUID that uniquely identifies the secret.
|
|
889
|
+
* @param {string} [params.policy] - The type of policy that is associated with the specified secret.
|
|
890
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
891
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSecretPolicies>>}
|
|
892
|
+
*/
|
|
893
|
+
SecretsManagerV1.prototype.getPolicy = function (params) {
|
|
894
|
+
var _params = __assign({}, params);
|
|
895
|
+
var _requiredParams = ['secretType', 'id'];
|
|
896
|
+
var _validParams = ['secretType', 'id', 'policy', 'headers'];
|
|
897
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
898
|
+
if (_validationErrors) {
|
|
899
|
+
return Promise.reject(_validationErrors);
|
|
900
|
+
}
|
|
901
|
+
var query = {
|
|
902
|
+
'policy': _params.policy,
|
|
903
|
+
};
|
|
904
|
+
var path = {
|
|
905
|
+
'secret_type': _params.secretType,
|
|
906
|
+
'id': _params.id,
|
|
907
|
+
};
|
|
908
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getPolicy');
|
|
909
|
+
var parameters = {
|
|
910
|
+
options: {
|
|
911
|
+
url: '/api/v1/secrets/{secret_type}/{id}/policies',
|
|
912
|
+
method: 'GET',
|
|
913
|
+
qs: query,
|
|
914
|
+
path: path,
|
|
915
|
+
},
|
|
916
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
917
|
+
headers: extend(true, sdkHeaders, {
|
|
918
|
+
'Accept': 'application/json',
|
|
919
|
+
}, _params.headers),
|
|
920
|
+
}),
|
|
921
|
+
};
|
|
922
|
+
return this.createRequest(parameters);
|
|
923
|
+
};
|
|
924
|
+
/*************************
|
|
925
|
+
* config
|
|
926
|
+
************************/
|
|
927
|
+
/**
|
|
928
|
+
* Set the configuration of a secret type.
|
|
929
|
+
*
|
|
930
|
+
* Sets the configuration for the specified secret type.
|
|
931
|
+
*
|
|
932
|
+
* Use this method to configure the IAM credentials (`iam_credentials`) engine for your service instance. Looking to
|
|
933
|
+
* set up certificate ordering? To configure the public certificates (`public_cert`) engine, use the [Add a
|
|
934
|
+
* configuration](#create_config_element) method.
|
|
935
|
+
*
|
|
936
|
+
* @param {Object} params - The parameters to send to the service.
|
|
937
|
+
* @param {string} params.secretType - The secret type.
|
|
938
|
+
* @param {EngineConfig} params.engineConfig - Properties to update for a secrets engine.
|
|
939
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
940
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.Empty>>}
|
|
941
|
+
*/
|
|
942
|
+
SecretsManagerV1.prototype.putConfig = function (params) {
|
|
943
|
+
var _params = __assign({}, params);
|
|
944
|
+
var _requiredParams = ['secretType', 'engineConfig'];
|
|
945
|
+
var _validParams = ['secretType', 'engineConfig', 'headers'];
|
|
946
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
947
|
+
if (_validationErrors) {
|
|
948
|
+
return Promise.reject(_validationErrors);
|
|
949
|
+
}
|
|
950
|
+
var body = _params.engineConfig;
|
|
951
|
+
var path = {
|
|
952
|
+
'secret_type': _params.secretType,
|
|
953
|
+
};
|
|
954
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'putConfig');
|
|
955
|
+
var parameters = {
|
|
956
|
+
options: {
|
|
957
|
+
url: '/api/v1/config/{secret_type}',
|
|
958
|
+
method: 'PUT',
|
|
959
|
+
body: body,
|
|
960
|
+
path: path,
|
|
961
|
+
},
|
|
962
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
963
|
+
headers: extend(true, sdkHeaders, {
|
|
964
|
+
'Content-Type': 'application/json',
|
|
965
|
+
}, _params.headers),
|
|
966
|
+
}),
|
|
967
|
+
};
|
|
968
|
+
return this.createRequest(parameters);
|
|
969
|
+
};
|
|
970
|
+
/**
|
|
971
|
+
* Get the configuration of a secret type.
|
|
972
|
+
*
|
|
973
|
+
* Retrieves the configuration that is associated with the specified secret type.
|
|
974
|
+
*
|
|
975
|
+
* @param {Object} params - The parameters to send to the service.
|
|
976
|
+
* @param {string} params.secretType - The secret type.
|
|
977
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
978
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetConfig>>}
|
|
979
|
+
*/
|
|
980
|
+
SecretsManagerV1.prototype.getConfig = function (params) {
|
|
981
|
+
var _params = __assign({}, params);
|
|
982
|
+
var _requiredParams = ['secretType'];
|
|
983
|
+
var _validParams = ['secretType', 'headers'];
|
|
984
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
985
|
+
if (_validationErrors) {
|
|
986
|
+
return Promise.reject(_validationErrors);
|
|
987
|
+
}
|
|
988
|
+
var path = {
|
|
989
|
+
'secret_type': _params.secretType,
|
|
990
|
+
};
|
|
991
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getConfig');
|
|
992
|
+
var parameters = {
|
|
993
|
+
options: {
|
|
994
|
+
url: '/api/v1/config/{secret_type}',
|
|
995
|
+
method: 'GET',
|
|
996
|
+
path: path,
|
|
997
|
+
},
|
|
998
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
999
|
+
headers: extend(true, sdkHeaders, {
|
|
1000
|
+
'Accept': 'application/json',
|
|
1001
|
+
}, _params.headers),
|
|
1002
|
+
}),
|
|
1003
|
+
};
|
|
1004
|
+
return this.createRequest(parameters);
|
|
1005
|
+
};
|
|
1006
|
+
/**
|
|
1007
|
+
* Add a configuration.
|
|
1008
|
+
*
|
|
1009
|
+
* Adds a configuration element to the specified secret type.
|
|
1010
|
+
*
|
|
1011
|
+
* Use this method to define the configurations that are required to enable the public certificates (`public_cert`)
|
|
1012
|
+
* engine. You can add up to 10 certificate authority and DNS provider configurations for your instance.
|
|
1013
|
+
*
|
|
1014
|
+
* @param {Object} params - The parameters to send to the service.
|
|
1015
|
+
* @param {string} params.secretType - The secret type.
|
|
1016
|
+
* @param {string} params.configElement - The configuration element to define or manage.
|
|
1017
|
+
* @param {string} params.name - The human-readable name to assign to your configuration.
|
|
1018
|
+
* @param {string} params.type - The type of configuration. Value options differ depending on the `config_element`
|
|
1019
|
+
* property that you want to define.
|
|
1020
|
+
* @param {JsonObject} params.config - The configuration to define for the specified secret type.
|
|
1021
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
1022
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSingleConfigElement>>}
|
|
1023
|
+
*/
|
|
1024
|
+
SecretsManagerV1.prototype.createConfigElement = function (params) {
|
|
1025
|
+
var _params = __assign({}, params);
|
|
1026
|
+
var _requiredParams = ['secretType', 'configElement', 'name', 'type', 'config'];
|
|
1027
|
+
var _validParams = ['secretType', 'configElement', 'name', 'type', 'config', 'headers'];
|
|
1028
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
1029
|
+
if (_validationErrors) {
|
|
1030
|
+
return Promise.reject(_validationErrors);
|
|
1031
|
+
}
|
|
1032
|
+
var body = {
|
|
1033
|
+
'name': _params.name,
|
|
1034
|
+
'type': _params.type,
|
|
1035
|
+
'config': _params.config,
|
|
1036
|
+
};
|
|
1037
|
+
var path = {
|
|
1038
|
+
'secret_type': _params.secretType,
|
|
1039
|
+
'config_element': _params.configElement,
|
|
1040
|
+
};
|
|
1041
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'createConfigElement');
|
|
1042
|
+
var parameters = {
|
|
1043
|
+
options: {
|
|
1044
|
+
url: '/api/v1/config/{secret_type}/{config_element}',
|
|
1045
|
+
method: 'POST',
|
|
1046
|
+
body: body,
|
|
1047
|
+
path: path,
|
|
1048
|
+
},
|
|
1049
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
1050
|
+
headers: extend(true, sdkHeaders, {
|
|
1051
|
+
'Accept': 'application/json',
|
|
1052
|
+
'Content-Type': 'application/json',
|
|
1053
|
+
}, _params.headers),
|
|
1054
|
+
}),
|
|
1055
|
+
};
|
|
1056
|
+
return this.createRequest(parameters);
|
|
1057
|
+
};
|
|
1058
|
+
/**
|
|
1059
|
+
* List configurations.
|
|
1060
|
+
*
|
|
1061
|
+
* Lists the configuration elements that are associated with a specified secret type.
|
|
1062
|
+
*
|
|
1063
|
+
* @param {Object} params - The parameters to send to the service.
|
|
1064
|
+
* @param {string} params.secretType - The secret type.
|
|
1065
|
+
* @param {string} params.configElement - The configuration element to define or manage.
|
|
1066
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
1067
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetConfigElements>>}
|
|
1068
|
+
*/
|
|
1069
|
+
SecretsManagerV1.prototype.getConfigElements = function (params) {
|
|
1070
|
+
var _params = __assign({}, params);
|
|
1071
|
+
var _requiredParams = ['secretType', 'configElement'];
|
|
1072
|
+
var _validParams = ['secretType', 'configElement', 'headers'];
|
|
1073
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
1074
|
+
if (_validationErrors) {
|
|
1075
|
+
return Promise.reject(_validationErrors);
|
|
1076
|
+
}
|
|
1077
|
+
var path = {
|
|
1078
|
+
'secret_type': _params.secretType,
|
|
1079
|
+
'config_element': _params.configElement,
|
|
1080
|
+
};
|
|
1081
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getConfigElements');
|
|
1082
|
+
var parameters = {
|
|
1083
|
+
options: {
|
|
1084
|
+
url: '/api/v1/config/{secret_type}/{config_element}',
|
|
1085
|
+
method: 'GET',
|
|
1086
|
+
path: path,
|
|
1087
|
+
},
|
|
1088
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
1089
|
+
headers: extend(true, sdkHeaders, {
|
|
1090
|
+
'Accept': 'application/json',
|
|
1091
|
+
}, _params.headers),
|
|
1092
|
+
}),
|
|
1093
|
+
};
|
|
1094
|
+
return this.createRequest(parameters);
|
|
1095
|
+
};
|
|
1096
|
+
/**
|
|
1097
|
+
* Get a configuration.
|
|
1098
|
+
*
|
|
1099
|
+
* Retrieves the details of a specific configuration that is associated with a secret type.
|
|
1100
|
+
*
|
|
1101
|
+
* @param {Object} params - The parameters to send to the service.
|
|
1102
|
+
* @param {string} params.secretType - The secret type.
|
|
1103
|
+
* @param {string} params.configElement - The configuration element to define or manage.
|
|
1104
|
+
* @param {string} params.configName - The name of your configuration.
|
|
1105
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
1106
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSingleConfigElement>>}
|
|
1107
|
+
*/
|
|
1108
|
+
SecretsManagerV1.prototype.getConfigElement = function (params) {
|
|
1109
|
+
var _params = __assign({}, params);
|
|
1110
|
+
var _requiredParams = ['secretType', 'configElement', 'configName'];
|
|
1111
|
+
var _validParams = ['secretType', 'configElement', 'configName', 'headers'];
|
|
1112
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
1113
|
+
if (_validationErrors) {
|
|
1114
|
+
return Promise.reject(_validationErrors);
|
|
1115
|
+
}
|
|
1116
|
+
var path = {
|
|
1117
|
+
'secret_type': _params.secretType,
|
|
1118
|
+
'config_element': _params.configElement,
|
|
1119
|
+
'config_name': _params.configName,
|
|
1120
|
+
};
|
|
1121
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'getConfigElement');
|
|
1122
|
+
var parameters = {
|
|
1123
|
+
options: {
|
|
1124
|
+
url: '/api/v1/config/{secret_type}/{config_element}/{config_name}',
|
|
1125
|
+
method: 'GET',
|
|
1126
|
+
path: path,
|
|
1127
|
+
},
|
|
1128
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
1129
|
+
headers: extend(true, sdkHeaders, {
|
|
1130
|
+
'Accept': 'application/json',
|
|
1131
|
+
}, _params.headers),
|
|
1132
|
+
}),
|
|
1133
|
+
};
|
|
1134
|
+
return this.createRequest(parameters);
|
|
1135
|
+
};
|
|
1136
|
+
/**
|
|
1137
|
+
* Update a configuration.
|
|
1138
|
+
*
|
|
1139
|
+
* Updates a configuration element that is associated with the specified secret type.
|
|
1140
|
+
*
|
|
1141
|
+
* @param {Object} params - The parameters to send to the service.
|
|
1142
|
+
* @param {string} params.secretType - The secret type.
|
|
1143
|
+
* @param {string} params.configElement - The configuration element to define or manage.
|
|
1144
|
+
* @param {string} params.configName - The name of your configuration.
|
|
1145
|
+
* @param {string} params.type - The type of configuration. Value options differ depending on the `config_element`
|
|
1146
|
+
* property that you want to define.
|
|
1147
|
+
* @param {JsonObject} params.config - Properties that describe a configuration, which depends on type.
|
|
1148
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
1149
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.GetSingleConfigElement>>}
|
|
1150
|
+
*/
|
|
1151
|
+
SecretsManagerV1.prototype.updateConfigElement = function (params) {
|
|
1152
|
+
var _params = __assign({}, params);
|
|
1153
|
+
var _requiredParams = ['secretType', 'configElement', 'configName', 'type', 'config'];
|
|
1154
|
+
var _validParams = ['secretType', 'configElement', 'configName', 'type', 'config', 'headers'];
|
|
1155
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
1156
|
+
if (_validationErrors) {
|
|
1157
|
+
return Promise.reject(_validationErrors);
|
|
1158
|
+
}
|
|
1159
|
+
var body = {
|
|
1160
|
+
'type': _params.type,
|
|
1161
|
+
'config': _params.config,
|
|
1162
|
+
};
|
|
1163
|
+
var path = {
|
|
1164
|
+
'secret_type': _params.secretType,
|
|
1165
|
+
'config_element': _params.configElement,
|
|
1166
|
+
'config_name': _params.configName,
|
|
1167
|
+
};
|
|
1168
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'updateConfigElement');
|
|
1169
|
+
var parameters = {
|
|
1170
|
+
options: {
|
|
1171
|
+
url: '/api/v1/config/{secret_type}/{config_element}/{config_name}',
|
|
1172
|
+
method: 'PUT',
|
|
1173
|
+
body: body,
|
|
1174
|
+
path: path,
|
|
1175
|
+
},
|
|
1176
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
1177
|
+
headers: extend(true, sdkHeaders, {
|
|
1178
|
+
'Accept': 'application/json',
|
|
1179
|
+
'Content-Type': 'application/json',
|
|
1180
|
+
}, _params.headers),
|
|
1181
|
+
}),
|
|
1182
|
+
};
|
|
1183
|
+
return this.createRequest(parameters);
|
|
1184
|
+
};
|
|
1185
|
+
/**
|
|
1186
|
+
* Delete a configuration.
|
|
1187
|
+
*
|
|
1188
|
+
* Deletes a configuration element from the specified secret type.
|
|
1189
|
+
*
|
|
1190
|
+
* @param {Object} params - The parameters to send to the service.
|
|
1191
|
+
* @param {string} params.secretType - The secret type.
|
|
1192
|
+
* @param {string} params.configElement - The configuration element to define or manage.
|
|
1193
|
+
* @param {string} params.configName - The name of your configuration.
|
|
1194
|
+
* @param {OutgoingHttpHeaders} [params.headers] - Custom request headers
|
|
1195
|
+
* @returns {Promise<SecretsManagerV1.Response<SecretsManagerV1.Empty>>}
|
|
1196
|
+
*/
|
|
1197
|
+
SecretsManagerV1.prototype.deleteConfigElement = function (params) {
|
|
1198
|
+
var _params = __assign({}, params);
|
|
1199
|
+
var _requiredParams = ['secretType', 'configElement', 'configName'];
|
|
1200
|
+
var _validParams = ['secretType', 'configElement', 'configName', 'headers'];
|
|
1201
|
+
var _validationErrors = ibm_cloud_sdk_core_1.validateParams(_params, _requiredParams, _validParams);
|
|
1202
|
+
if (_validationErrors) {
|
|
1203
|
+
return Promise.reject(_validationErrors);
|
|
1204
|
+
}
|
|
1205
|
+
var path = {
|
|
1206
|
+
'secret_type': _params.secretType,
|
|
1207
|
+
'config_element': _params.configElement,
|
|
1208
|
+
'config_name': _params.configName,
|
|
1209
|
+
};
|
|
1210
|
+
var sdkHeaders = common_1.getSdkHeaders(SecretsManagerV1.DEFAULT_SERVICE_NAME, 'v1', 'deleteConfigElement');
|
|
1211
|
+
var parameters = {
|
|
1212
|
+
options: {
|
|
1213
|
+
url: '/api/v1/config/{secret_type}/{config_element}/{config_name}',
|
|
1214
|
+
method: 'DELETE',
|
|
1215
|
+
path: path,
|
|
1216
|
+
},
|
|
1217
|
+
defaultOptions: extend(true, {}, this.baseOptions, {
|
|
1218
|
+
headers: extend(true, sdkHeaders, {}, _params.headers),
|
|
1219
|
+
}),
|
|
1220
|
+
};
|
|
1221
|
+
return this.createRequest(parameters);
|
|
1222
|
+
};
|
|
1223
|
+
SecretsManagerV1.DEFAULT_SERVICE_URL = 'https://secrets-manager.cloud.ibm.com';
|
|
1224
|
+
SecretsManagerV1.DEFAULT_SERVICE_NAME = 'secrets_manager';
|
|
1225
|
+
return SecretsManagerV1;
|
|
1226
|
+
}(ibm_cloud_sdk_core_1.BaseService));
|
|
1227
|
+
/*************************
|
|
1228
|
+
* interfaces
|
|
1229
|
+
************************/
|
|
1230
|
+
(function (SecretsManagerV1) {
|
|
896
1231
|
/** Constants for the `createSecret` operation. */
|
|
897
1232
|
var CreateSecretConstants;
|
|
898
1233
|
(function (CreateSecretConstants) {
|
|
@@ -900,8 +1235,11 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
900
1235
|
var SecretType;
|
|
901
1236
|
(function (SecretType) {
|
|
902
1237
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
903
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
904
1238
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1239
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1240
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1241
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1242
|
+
SecretType["KV"] = "kv";
|
|
905
1243
|
})(SecretType = CreateSecretConstants.SecretType || (CreateSecretConstants.SecretType = {}));
|
|
906
1244
|
})(CreateSecretConstants = SecretsManagerV1.CreateSecretConstants || (SecretsManagerV1.CreateSecretConstants = {}));
|
|
907
1245
|
/** Constants for the `listSecrets` operation. */
|
|
@@ -911,8 +1249,11 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
911
1249
|
var SecretType;
|
|
912
1250
|
(function (SecretType) {
|
|
913
1251
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
914
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
915
1252
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1253
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1254
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1255
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1256
|
+
SecretType["KV"] = "kv";
|
|
916
1257
|
})(SecretType = ListSecretsConstants.SecretType || (ListSecretsConstants.SecretType = {}));
|
|
917
1258
|
})(ListSecretsConstants = SecretsManagerV1.ListSecretsConstants || (SecretsManagerV1.ListSecretsConstants = {}));
|
|
918
1259
|
/** Constants for the `listAllSecrets` operation. */
|
|
@@ -935,8 +1276,11 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
935
1276
|
var SecretType;
|
|
936
1277
|
(function (SecretType) {
|
|
937
1278
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
938
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
939
1279
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1280
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1281
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1282
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1283
|
+
SecretType["KV"] = "kv";
|
|
940
1284
|
})(SecretType = GetSecretConstants.SecretType || (GetSecretConstants.SecretType = {}));
|
|
941
1285
|
})(GetSecretConstants = SecretsManagerV1.GetSecretConstants || (SecretsManagerV1.GetSecretConstants = {}));
|
|
942
1286
|
/** Constants for the `updateSecret` operation. */
|
|
@@ -946,13 +1290,17 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
946
1290
|
var SecretType;
|
|
947
1291
|
(function (SecretType) {
|
|
948
1292
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
949
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
950
1293
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1294
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1295
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1296
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1297
|
+
SecretType["KV"] = "kv";
|
|
951
1298
|
})(SecretType = UpdateSecretConstants.SecretType || (UpdateSecretConstants.SecretType = {}));
|
|
952
1299
|
/** The action to perform on the specified secret. */
|
|
953
1300
|
var Action;
|
|
954
1301
|
(function (Action) {
|
|
955
1302
|
Action["ROTATE"] = "rotate";
|
|
1303
|
+
Action["RESTORE"] = "restore";
|
|
956
1304
|
Action["DELETE_CREDENTIALS"] = "delete_credentials";
|
|
957
1305
|
})(Action = UpdateSecretConstants.Action || (UpdateSecretConstants.Action = {}));
|
|
958
1306
|
})(UpdateSecretConstants = SecretsManagerV1.UpdateSecretConstants || (SecretsManagerV1.UpdateSecretConstants = {}));
|
|
@@ -963,10 +1311,55 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
963
1311
|
var SecretType;
|
|
964
1312
|
(function (SecretType) {
|
|
965
1313
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
966
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
967
1314
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1315
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1316
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1317
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1318
|
+
SecretType["KV"] = "kv";
|
|
968
1319
|
})(SecretType = DeleteSecretConstants.SecretType || (DeleteSecretConstants.SecretType = {}));
|
|
969
1320
|
})(DeleteSecretConstants = SecretsManagerV1.DeleteSecretConstants || (SecretsManagerV1.DeleteSecretConstants = {}));
|
|
1321
|
+
/** Constants for the `listSecretVersions` operation. */
|
|
1322
|
+
var ListSecretVersionsConstants;
|
|
1323
|
+
(function (ListSecretVersionsConstants) {
|
|
1324
|
+
/** The secret type. */
|
|
1325
|
+
var SecretType;
|
|
1326
|
+
(function (SecretType) {
|
|
1327
|
+
SecretType["ARBITRARY"] = "arbitrary";
|
|
1328
|
+
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1329
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1330
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1331
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1332
|
+
SecretType["KV"] = "kv";
|
|
1333
|
+
})(SecretType = ListSecretVersionsConstants.SecretType || (ListSecretVersionsConstants.SecretType = {}));
|
|
1334
|
+
})(ListSecretVersionsConstants = SecretsManagerV1.ListSecretVersionsConstants || (SecretsManagerV1.ListSecretVersionsConstants = {}));
|
|
1335
|
+
/** Constants for the `getSecretVersion` operation. */
|
|
1336
|
+
var GetSecretVersionConstants;
|
|
1337
|
+
(function (GetSecretVersionConstants) {
|
|
1338
|
+
/** The secret type. */
|
|
1339
|
+
var SecretType;
|
|
1340
|
+
(function (SecretType) {
|
|
1341
|
+
SecretType["ARBITRARY"] = "arbitrary";
|
|
1342
|
+
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1343
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1344
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1345
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1346
|
+
SecretType["KV"] = "kv";
|
|
1347
|
+
})(SecretType = GetSecretVersionConstants.SecretType || (GetSecretVersionConstants.SecretType = {}));
|
|
1348
|
+
})(GetSecretVersionConstants = SecretsManagerV1.GetSecretVersionConstants || (SecretsManagerV1.GetSecretVersionConstants = {}));
|
|
1349
|
+
/** Constants for the `getSecretVersionMetadata` operation. */
|
|
1350
|
+
var GetSecretVersionMetadataConstants;
|
|
1351
|
+
(function (GetSecretVersionMetadataConstants) {
|
|
1352
|
+
/** The secret type. */
|
|
1353
|
+
var SecretType;
|
|
1354
|
+
(function (SecretType) {
|
|
1355
|
+
SecretType["ARBITRARY"] = "arbitrary";
|
|
1356
|
+
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1357
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1358
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1359
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1360
|
+
SecretType["KV"] = "kv";
|
|
1361
|
+
})(SecretType = GetSecretVersionMetadataConstants.SecretType || (GetSecretVersionMetadataConstants.SecretType = {}));
|
|
1362
|
+
})(GetSecretVersionMetadataConstants = SecretsManagerV1.GetSecretVersionMetadataConstants || (SecretsManagerV1.GetSecretVersionMetadataConstants = {}));
|
|
970
1363
|
/** Constants for the `getSecretMetadata` operation. */
|
|
971
1364
|
var GetSecretMetadataConstants;
|
|
972
1365
|
(function (GetSecretMetadataConstants) {
|
|
@@ -974,8 +1367,11 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
974
1367
|
var SecretType;
|
|
975
1368
|
(function (SecretType) {
|
|
976
1369
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
977
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
978
1370
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1371
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1372
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1373
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1374
|
+
SecretType["KV"] = "kv";
|
|
979
1375
|
})(SecretType = GetSecretMetadataConstants.SecretType || (GetSecretMetadataConstants.SecretType = {}));
|
|
980
1376
|
})(GetSecretMetadataConstants = SecretsManagerV1.GetSecretMetadataConstants || (SecretsManagerV1.GetSecretMetadataConstants = {}));
|
|
981
1377
|
/** Constants for the `updateSecretMetadata` operation. */
|
|
@@ -985,10 +1381,153 @@ var SecretsManagerV1 = /** @class */ (function (_super) {
|
|
|
985
1381
|
var SecretType;
|
|
986
1382
|
(function (SecretType) {
|
|
987
1383
|
SecretType["ARBITRARY"] = "arbitrary";
|
|
988
|
-
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
989
1384
|
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1385
|
+
SecretType["IMPORTED_CERT"] = "imported_cert";
|
|
1386
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1387
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1388
|
+
SecretType["KV"] = "kv";
|
|
990
1389
|
})(SecretType = UpdateSecretMetadataConstants.SecretType || (UpdateSecretMetadataConstants.SecretType = {}));
|
|
991
1390
|
})(UpdateSecretMetadataConstants = SecretsManagerV1.UpdateSecretMetadataConstants || (SecretsManagerV1.UpdateSecretMetadataConstants = {}));
|
|
1391
|
+
/** Constants for the `putPolicy` operation. */
|
|
1392
|
+
var PutPolicyConstants;
|
|
1393
|
+
(function (PutPolicyConstants) {
|
|
1394
|
+
/** The secret type. */
|
|
1395
|
+
var SecretType;
|
|
1396
|
+
(function (SecretType) {
|
|
1397
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1398
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1399
|
+
})(SecretType = PutPolicyConstants.SecretType || (PutPolicyConstants.SecretType = {}));
|
|
1400
|
+
/** The type of policy that is associated with the specified secret. */
|
|
1401
|
+
var Policy;
|
|
1402
|
+
(function (Policy) {
|
|
1403
|
+
Policy["ROTATION"] = "rotation";
|
|
1404
|
+
})(Policy = PutPolicyConstants.Policy || (PutPolicyConstants.Policy = {}));
|
|
1405
|
+
})(PutPolicyConstants = SecretsManagerV1.PutPolicyConstants || (SecretsManagerV1.PutPolicyConstants = {}));
|
|
1406
|
+
/** Constants for the `getPolicy` operation. */
|
|
1407
|
+
var GetPolicyConstants;
|
|
1408
|
+
(function (GetPolicyConstants) {
|
|
1409
|
+
/** The secret type. */
|
|
1410
|
+
var SecretType;
|
|
1411
|
+
(function (SecretType) {
|
|
1412
|
+
SecretType["USERNAME_PASSWORD"] = "username_password";
|
|
1413
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1414
|
+
})(SecretType = GetPolicyConstants.SecretType || (GetPolicyConstants.SecretType = {}));
|
|
1415
|
+
/** The type of policy that is associated with the specified secret. */
|
|
1416
|
+
var Policy;
|
|
1417
|
+
(function (Policy) {
|
|
1418
|
+
Policy["ROTATION"] = "rotation";
|
|
1419
|
+
})(Policy = GetPolicyConstants.Policy || (GetPolicyConstants.Policy = {}));
|
|
1420
|
+
})(GetPolicyConstants = SecretsManagerV1.GetPolicyConstants || (SecretsManagerV1.GetPolicyConstants = {}));
|
|
1421
|
+
/** Constants for the `putConfig` operation. */
|
|
1422
|
+
var PutConfigConstants;
|
|
1423
|
+
(function (PutConfigConstants) {
|
|
1424
|
+
/** The secret type. */
|
|
1425
|
+
var SecretType;
|
|
1426
|
+
(function (SecretType) {
|
|
1427
|
+
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1428
|
+
})(SecretType = PutConfigConstants.SecretType || (PutConfigConstants.SecretType = {}));
|
|
1429
|
+
})(PutConfigConstants = SecretsManagerV1.PutConfigConstants || (SecretsManagerV1.PutConfigConstants = {}));
|
|
1430
|
+
/** Constants for the `getConfig` operation. */
|
|
1431
|
+
var GetConfigConstants;
|
|
1432
|
+
(function (GetConfigConstants) {
|
|
1433
|
+
/** The secret type. */
|
|
1434
|
+
var SecretType;
|
|
1435
|
+
(function (SecretType) {
|
|
1436
|
+
SecretType["IAM_CREDENTIALS"] = "iam_credentials";
|
|
1437
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1438
|
+
})(SecretType = GetConfigConstants.SecretType || (GetConfigConstants.SecretType = {}));
|
|
1439
|
+
})(GetConfigConstants = SecretsManagerV1.GetConfigConstants || (SecretsManagerV1.GetConfigConstants = {}));
|
|
1440
|
+
/** Constants for the `createConfigElement` operation. */
|
|
1441
|
+
var CreateConfigElementConstants;
|
|
1442
|
+
(function (CreateConfigElementConstants) {
|
|
1443
|
+
/** The secret type. */
|
|
1444
|
+
var SecretType;
|
|
1445
|
+
(function (SecretType) {
|
|
1446
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1447
|
+
})(SecretType = CreateConfigElementConstants.SecretType || (CreateConfigElementConstants.SecretType = {}));
|
|
1448
|
+
/** The configuration element to define or manage. */
|
|
1449
|
+
var ConfigElement;
|
|
1450
|
+
(function (ConfigElement) {
|
|
1451
|
+
ConfigElement["CERTIFICATE_AUTHORITIES"] = "certificate_authorities";
|
|
1452
|
+
ConfigElement["DNS_PROVIDERS"] = "dns_providers";
|
|
1453
|
+
})(ConfigElement = CreateConfigElementConstants.ConfigElement || (CreateConfigElementConstants.ConfigElement = {}));
|
|
1454
|
+
/** The type of configuration. Value options differ depending on the `config_element` property that you want to define. */
|
|
1455
|
+
var Type;
|
|
1456
|
+
(function (Type) {
|
|
1457
|
+
Type["LETSENCRYPT"] = "letsencrypt";
|
|
1458
|
+
Type["LETSENCRYPT_STAGE"] = "letsencrypt-stage";
|
|
1459
|
+
Type["CIS"] = "cis";
|
|
1460
|
+
Type["CLASSIC_INFRASTRUCTURE"] = "classic_infrastructure";
|
|
1461
|
+
})(Type = CreateConfigElementConstants.Type || (CreateConfigElementConstants.Type = {}));
|
|
1462
|
+
})(CreateConfigElementConstants = SecretsManagerV1.CreateConfigElementConstants || (SecretsManagerV1.CreateConfigElementConstants = {}));
|
|
1463
|
+
/** Constants for the `getConfigElements` operation. */
|
|
1464
|
+
var GetConfigElementsConstants;
|
|
1465
|
+
(function (GetConfigElementsConstants) {
|
|
1466
|
+
/** The secret type. */
|
|
1467
|
+
var SecretType;
|
|
1468
|
+
(function (SecretType) {
|
|
1469
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1470
|
+
})(SecretType = GetConfigElementsConstants.SecretType || (GetConfigElementsConstants.SecretType = {}));
|
|
1471
|
+
/** The configuration element to define or manage. */
|
|
1472
|
+
var ConfigElement;
|
|
1473
|
+
(function (ConfigElement) {
|
|
1474
|
+
ConfigElement["CERTIFICATE_AUTHORITIES"] = "certificate_authorities";
|
|
1475
|
+
ConfigElement["DNS_PROVIDERS"] = "dns_providers";
|
|
1476
|
+
})(ConfigElement = GetConfigElementsConstants.ConfigElement || (GetConfigElementsConstants.ConfigElement = {}));
|
|
1477
|
+
})(GetConfigElementsConstants = SecretsManagerV1.GetConfigElementsConstants || (SecretsManagerV1.GetConfigElementsConstants = {}));
|
|
1478
|
+
/** Constants for the `getConfigElement` operation. */
|
|
1479
|
+
var GetConfigElementConstants;
|
|
1480
|
+
(function (GetConfigElementConstants) {
|
|
1481
|
+
/** The secret type. */
|
|
1482
|
+
var SecretType;
|
|
1483
|
+
(function (SecretType) {
|
|
1484
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1485
|
+
})(SecretType = GetConfigElementConstants.SecretType || (GetConfigElementConstants.SecretType = {}));
|
|
1486
|
+
/** The configuration element to define or manage. */
|
|
1487
|
+
var ConfigElement;
|
|
1488
|
+
(function (ConfigElement) {
|
|
1489
|
+
ConfigElement["CERTIFICATE_AUTHORITIES"] = "certificate_authorities";
|
|
1490
|
+
ConfigElement["DNS_PROVIDERS"] = "dns_providers";
|
|
1491
|
+
})(ConfigElement = GetConfigElementConstants.ConfigElement || (GetConfigElementConstants.ConfigElement = {}));
|
|
1492
|
+
})(GetConfigElementConstants = SecretsManagerV1.GetConfigElementConstants || (SecretsManagerV1.GetConfigElementConstants = {}));
|
|
1493
|
+
/** Constants for the `updateConfigElement` operation. */
|
|
1494
|
+
var UpdateConfigElementConstants;
|
|
1495
|
+
(function (UpdateConfigElementConstants) {
|
|
1496
|
+
/** The secret type. */
|
|
1497
|
+
var SecretType;
|
|
1498
|
+
(function (SecretType) {
|
|
1499
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1500
|
+
})(SecretType = UpdateConfigElementConstants.SecretType || (UpdateConfigElementConstants.SecretType = {}));
|
|
1501
|
+
/** The configuration element to define or manage. */
|
|
1502
|
+
var ConfigElement;
|
|
1503
|
+
(function (ConfigElement) {
|
|
1504
|
+
ConfigElement["CERTIFICATE_AUTHORITIES"] = "certificate_authorities";
|
|
1505
|
+
ConfigElement["DNS_PROVIDERS"] = "dns_providers";
|
|
1506
|
+
})(ConfigElement = UpdateConfigElementConstants.ConfigElement || (UpdateConfigElementConstants.ConfigElement = {}));
|
|
1507
|
+
/** The type of configuration. Value options differ depending on the `config_element` property that you want to define. */
|
|
1508
|
+
var Type;
|
|
1509
|
+
(function (Type) {
|
|
1510
|
+
Type["LETSENCRYPT"] = "letsencrypt";
|
|
1511
|
+
Type["LETSENCRYPT_STAGE"] = "letsencrypt-stage";
|
|
1512
|
+
Type["CIS"] = "cis";
|
|
1513
|
+
Type["CLASSIC_INFRASTRUCTURE"] = "classic_infrastructure";
|
|
1514
|
+
})(Type = UpdateConfigElementConstants.Type || (UpdateConfigElementConstants.Type = {}));
|
|
1515
|
+
})(UpdateConfigElementConstants = SecretsManagerV1.UpdateConfigElementConstants || (SecretsManagerV1.UpdateConfigElementConstants = {}));
|
|
1516
|
+
/** Constants for the `deleteConfigElement` operation. */
|
|
1517
|
+
var DeleteConfigElementConstants;
|
|
1518
|
+
(function (DeleteConfigElementConstants) {
|
|
1519
|
+
/** The secret type. */
|
|
1520
|
+
var SecretType;
|
|
1521
|
+
(function (SecretType) {
|
|
1522
|
+
SecretType["PUBLIC_CERT"] = "public_cert";
|
|
1523
|
+
})(SecretType = DeleteConfigElementConstants.SecretType || (DeleteConfigElementConstants.SecretType = {}));
|
|
1524
|
+
/** The configuration element to define or manage. */
|
|
1525
|
+
var ConfigElement;
|
|
1526
|
+
(function (ConfigElement) {
|
|
1527
|
+
ConfigElement["CERTIFICATE_AUTHORITIES"] = "certificate_authorities";
|
|
1528
|
+
ConfigElement["DNS_PROVIDERS"] = "dns_providers";
|
|
1529
|
+
})(ConfigElement = DeleteConfigElementConstants.ConfigElement || (DeleteConfigElementConstants.ConfigElement = {}));
|
|
1530
|
+
})(DeleteConfigElementConstants = SecretsManagerV1.DeleteConfigElementConstants || (SecretsManagerV1.DeleteConfigElementConstants = {}));
|
|
992
1531
|
})(SecretsManagerV1 || (SecretsManagerV1 = {}));
|
|
993
1532
|
module.exports = SecretsManagerV1;
|
|
994
1533
|
//# sourceMappingURL=v1.js.map
|