@aws-sdk/client-finspace 3.474.0 → 3.477.0
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/dist-cjs/protocols/Aws_restJson1.js +311 -696
- package/dist-es/protocols/Aws_restJson1.js +312 -697
- package/package.json +5 -4
|
@@ -1,14 +1,14 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp,
|
|
1
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
2
|
+
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
|
|
3
3
|
import { v4 as generateIdempotencyToken } from "uuid";
|
|
4
4
|
import { FinspaceServiceException as __BaseException } from "../models/FinspaceServiceException";
|
|
5
5
|
import { AccessDeniedException, ConflictException, InternalServerException, InvalidRequestException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
|
|
6
6
|
export const se_CreateEnvironmentCommand = async (input, context) => {
|
|
7
|
-
const
|
|
7
|
+
const b = rb(input, context);
|
|
8
8
|
const headers = {
|
|
9
9
|
"content-type": "application/json",
|
|
10
10
|
};
|
|
11
|
-
|
|
11
|
+
b.bp("/environment");
|
|
12
12
|
let body;
|
|
13
13
|
body = JSON.stringify(take(input, {
|
|
14
14
|
dataBundles: (_) => _json(_),
|
|
@@ -20,47 +20,32 @@ export const se_CreateEnvironmentCommand = async (input, context) => {
|
|
|
20
20
|
superuserParameters: (_) => _json(_),
|
|
21
21
|
tags: (_) => _json(_),
|
|
22
22
|
}));
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
hostname,
|
|
26
|
-
port,
|
|
27
|
-
method: "POST",
|
|
28
|
-
headers,
|
|
29
|
-
path: resolvedPath,
|
|
30
|
-
body,
|
|
31
|
-
});
|
|
23
|
+
b.m("POST").h(headers).b(body);
|
|
24
|
+
return b.build();
|
|
32
25
|
};
|
|
33
26
|
export const se_CreateKxChangesetCommand = async (input, context) => {
|
|
34
|
-
const
|
|
27
|
+
const b = rb(input, context);
|
|
35
28
|
const headers = {
|
|
36
29
|
"content-type": "application/json",
|
|
37
30
|
};
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
31
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/changesets");
|
|
32
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
33
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
42
34
|
let body;
|
|
43
35
|
body = JSON.stringify(take(input, {
|
|
44
36
|
changeRequests: (_) => _json(_),
|
|
45
37
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
46
38
|
}));
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
hostname,
|
|
50
|
-
port,
|
|
51
|
-
method: "POST",
|
|
52
|
-
headers,
|
|
53
|
-
path: resolvedPath,
|
|
54
|
-
body,
|
|
55
|
-
});
|
|
39
|
+
b.m("POST").h(headers).b(body);
|
|
40
|
+
return b.build();
|
|
56
41
|
};
|
|
57
42
|
export const se_CreateKxClusterCommand = async (input, context) => {
|
|
58
|
-
const
|
|
43
|
+
const b = rb(input, context);
|
|
59
44
|
const headers = {
|
|
60
45
|
"content-type": "application/json",
|
|
61
46
|
};
|
|
62
|
-
|
|
63
|
-
|
|
47
|
+
b.bp("/kx/environments/{environmentId}/clusters");
|
|
48
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
64
49
|
let body;
|
|
65
50
|
body = JSON.stringify(take(input, {
|
|
66
51
|
autoScalingConfiguration: (_) => se_AutoScalingConfiguration(_, context),
|
|
@@ -84,24 +69,16 @@ export const se_CreateKxClusterCommand = async (input, context) => {
|
|
|
84
69
|
tickerplantLogConfiguration: (_) => _json(_),
|
|
85
70
|
vpcConfiguration: (_) => _json(_),
|
|
86
71
|
}));
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
hostname,
|
|
90
|
-
port,
|
|
91
|
-
method: "POST",
|
|
92
|
-
headers,
|
|
93
|
-
path: resolvedPath,
|
|
94
|
-
body,
|
|
95
|
-
});
|
|
72
|
+
b.m("POST").h(headers).b(body);
|
|
73
|
+
return b.build();
|
|
96
74
|
};
|
|
97
75
|
export const se_CreateKxDatabaseCommand = async (input, context) => {
|
|
98
|
-
const
|
|
76
|
+
const b = rb(input, context);
|
|
99
77
|
const headers = {
|
|
100
78
|
"content-type": "application/json",
|
|
101
79
|
};
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
80
|
+
b.bp("/kx/environments/{environmentId}/databases");
|
|
81
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
105
82
|
let body;
|
|
106
83
|
body = JSON.stringify(take(input, {
|
|
107
84
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -109,25 +86,17 @@ export const se_CreateKxDatabaseCommand = async (input, context) => {
|
|
|
109
86
|
description: [],
|
|
110
87
|
tags: (_) => _json(_),
|
|
111
88
|
}));
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
hostname,
|
|
115
|
-
port,
|
|
116
|
-
method: "POST",
|
|
117
|
-
headers,
|
|
118
|
-
path: resolvedPath,
|
|
119
|
-
body,
|
|
120
|
-
});
|
|
89
|
+
b.m("POST").h(headers).b(body);
|
|
90
|
+
return b.build();
|
|
121
91
|
};
|
|
122
92
|
export const se_CreateKxDataviewCommand = async (input, context) => {
|
|
123
|
-
const
|
|
93
|
+
const b = rb(input, context);
|
|
124
94
|
const headers = {
|
|
125
95
|
"content-type": "application/json",
|
|
126
96
|
};
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
97
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/dataviews");
|
|
98
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
99
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
131
100
|
let body;
|
|
132
101
|
body = JSON.stringify(take(input, {
|
|
133
102
|
autoUpdate: [],
|
|
@@ -140,22 +109,15 @@ export const se_CreateKxDataviewCommand = async (input, context) => {
|
|
|
140
109
|
segmentConfigurations: (_) => _json(_),
|
|
141
110
|
tags: (_) => _json(_),
|
|
142
111
|
}));
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
hostname,
|
|
146
|
-
port,
|
|
147
|
-
method: "POST",
|
|
148
|
-
headers,
|
|
149
|
-
path: resolvedPath,
|
|
150
|
-
body,
|
|
151
|
-
});
|
|
112
|
+
b.m("POST").h(headers).b(body);
|
|
113
|
+
return b.build();
|
|
152
114
|
};
|
|
153
115
|
export const se_CreateKxEnvironmentCommand = async (input, context) => {
|
|
154
|
-
const
|
|
116
|
+
const b = rb(input, context);
|
|
155
117
|
const headers = {
|
|
156
118
|
"content-type": "application/json",
|
|
157
119
|
};
|
|
158
|
-
|
|
120
|
+
b.bp("/kx/environments");
|
|
159
121
|
let body;
|
|
160
122
|
body = JSON.stringify(take(input, {
|
|
161
123
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -164,24 +126,16 @@ export const se_CreateKxEnvironmentCommand = async (input, context) => {
|
|
|
164
126
|
name: [],
|
|
165
127
|
tags: (_) => _json(_),
|
|
166
128
|
}));
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
hostname,
|
|
170
|
-
port,
|
|
171
|
-
method: "POST",
|
|
172
|
-
headers,
|
|
173
|
-
path: resolvedPath,
|
|
174
|
-
body,
|
|
175
|
-
});
|
|
129
|
+
b.m("POST").h(headers).b(body);
|
|
130
|
+
return b.build();
|
|
176
131
|
};
|
|
177
132
|
export const se_CreateKxScalingGroupCommand = async (input, context) => {
|
|
178
|
-
const
|
|
133
|
+
const b = rb(input, context);
|
|
179
134
|
const headers = {
|
|
180
135
|
"content-type": "application/json",
|
|
181
136
|
};
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
137
|
+
b.bp("/kx/environments/{environmentId}/scalingGroups");
|
|
138
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
185
139
|
let body;
|
|
186
140
|
body = JSON.stringify(take(input, {
|
|
187
141
|
availabilityZoneId: [],
|
|
@@ -190,23 +144,16 @@ export const se_CreateKxScalingGroupCommand = async (input, context) => {
|
|
|
190
144
|
scalingGroupName: [],
|
|
191
145
|
tags: (_) => _json(_),
|
|
192
146
|
}));
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
hostname,
|
|
196
|
-
port,
|
|
197
|
-
method: "POST",
|
|
198
|
-
headers,
|
|
199
|
-
path: resolvedPath,
|
|
200
|
-
body,
|
|
201
|
-
});
|
|
147
|
+
b.m("POST").h(headers).b(body);
|
|
148
|
+
return b.build();
|
|
202
149
|
};
|
|
203
150
|
export const se_CreateKxUserCommand = async (input, context) => {
|
|
204
|
-
const
|
|
151
|
+
const b = rb(input, context);
|
|
205
152
|
const headers = {
|
|
206
153
|
"content-type": "application/json",
|
|
207
154
|
};
|
|
208
|
-
|
|
209
|
-
|
|
155
|
+
b.bp("/kx/environments/{environmentId}/users");
|
|
156
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
210
157
|
let body;
|
|
211
158
|
body = JSON.stringify(take(input, {
|
|
212
159
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -214,24 +161,16 @@ export const se_CreateKxUserCommand = async (input, context) => {
|
|
|
214
161
|
tags: (_) => _json(_),
|
|
215
162
|
userName: [],
|
|
216
163
|
}));
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
hostname,
|
|
220
|
-
port,
|
|
221
|
-
method: "POST",
|
|
222
|
-
headers,
|
|
223
|
-
path: resolvedPath,
|
|
224
|
-
body,
|
|
225
|
-
});
|
|
164
|
+
b.m("POST").h(headers).b(body);
|
|
165
|
+
return b.build();
|
|
226
166
|
};
|
|
227
167
|
export const se_CreateKxVolumeCommand = async (input, context) => {
|
|
228
|
-
const
|
|
168
|
+
const b = rb(input, context);
|
|
229
169
|
const headers = {
|
|
230
170
|
"content-type": "application/json",
|
|
231
171
|
};
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
172
|
+
b.bp("/kx/environments/{environmentId}/kxvolumes");
|
|
173
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
235
174
|
let body;
|
|
236
175
|
body = JSON.stringify(take(input, {
|
|
237
176
|
availabilityZoneIds: (_) => _json(_),
|
|
@@ -243,653 +182,390 @@ export const se_CreateKxVolumeCommand = async (input, context) => {
|
|
|
243
182
|
volumeName: [],
|
|
244
183
|
volumeType: [],
|
|
245
184
|
}));
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
hostname,
|
|
249
|
-
port,
|
|
250
|
-
method: "POST",
|
|
251
|
-
headers,
|
|
252
|
-
path: resolvedPath,
|
|
253
|
-
body,
|
|
254
|
-
});
|
|
185
|
+
b.m("POST").h(headers).b(body);
|
|
186
|
+
return b.build();
|
|
255
187
|
};
|
|
256
188
|
export const se_DeleteEnvironmentCommand = async (input, context) => {
|
|
257
|
-
const
|
|
189
|
+
const b = rb(input, context);
|
|
258
190
|
const headers = {};
|
|
259
|
-
|
|
260
|
-
|
|
191
|
+
b.bp("/environment/{environmentId}");
|
|
192
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
261
193
|
let body;
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
hostname,
|
|
265
|
-
port,
|
|
266
|
-
method: "DELETE",
|
|
267
|
-
headers,
|
|
268
|
-
path: resolvedPath,
|
|
269
|
-
body,
|
|
270
|
-
});
|
|
194
|
+
b.m("DELETE").h(headers).b(body);
|
|
195
|
+
return b.build();
|
|
271
196
|
};
|
|
272
197
|
export const se_DeleteKxClusterCommand = async (input, context) => {
|
|
273
|
-
const
|
|
198
|
+
const b = rb(input, context);
|
|
274
199
|
const headers = {};
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
|
|
200
|
+
b.bp("/kx/environments/{environmentId}/clusters/{clusterName}");
|
|
201
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
202
|
+
b.p("clusterName", () => input.clusterName, "{clusterName}", false);
|
|
279
203
|
const query = map({
|
|
280
|
-
|
|
204
|
+
[_cT]: [, input[_cT] ?? generateIdempotencyToken()],
|
|
281
205
|
});
|
|
282
206
|
let body;
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
hostname,
|
|
286
|
-
port,
|
|
287
|
-
method: "DELETE",
|
|
288
|
-
headers,
|
|
289
|
-
path: resolvedPath,
|
|
290
|
-
query,
|
|
291
|
-
body,
|
|
292
|
-
});
|
|
207
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
208
|
+
return b.build();
|
|
293
209
|
};
|
|
294
210
|
export const se_DeleteKxDatabaseCommand = async (input, context) => {
|
|
295
|
-
const
|
|
211
|
+
const b = rb(input, context);
|
|
296
212
|
const headers = {};
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
213
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}");
|
|
214
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
215
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
301
216
|
const query = map({
|
|
302
|
-
|
|
217
|
+
[_cT]: [, __expectNonNull(input[_cT], `clientToken`)],
|
|
303
218
|
});
|
|
304
219
|
let body;
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
hostname,
|
|
308
|
-
port,
|
|
309
|
-
method: "DELETE",
|
|
310
|
-
headers,
|
|
311
|
-
path: resolvedPath,
|
|
312
|
-
query,
|
|
313
|
-
body,
|
|
314
|
-
});
|
|
220
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
221
|
+
return b.build();
|
|
315
222
|
};
|
|
316
223
|
export const se_DeleteKxDataviewCommand = async (input, context) => {
|
|
317
|
-
const
|
|
224
|
+
const b = rb(input, context);
|
|
318
225
|
const headers = {};
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
226
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}");
|
|
227
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
228
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
229
|
+
b.p("dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
324
230
|
const query = map({
|
|
325
|
-
|
|
231
|
+
[_cT]: [, __expectNonNull(input[_cT], `clientToken`)],
|
|
326
232
|
});
|
|
327
233
|
let body;
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
hostname,
|
|
331
|
-
port,
|
|
332
|
-
method: "DELETE",
|
|
333
|
-
headers,
|
|
334
|
-
path: resolvedPath,
|
|
335
|
-
query,
|
|
336
|
-
body,
|
|
337
|
-
});
|
|
234
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
235
|
+
return b.build();
|
|
338
236
|
};
|
|
339
237
|
export const se_DeleteKxEnvironmentCommand = async (input, context) => {
|
|
340
|
-
const
|
|
238
|
+
const b = rb(input, context);
|
|
341
239
|
const headers = {};
|
|
342
|
-
|
|
343
|
-
|
|
240
|
+
b.bp("/kx/environments/{environmentId}");
|
|
241
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
344
242
|
const query = map({
|
|
345
|
-
|
|
243
|
+
[_cT]: [, input[_cT] ?? generateIdempotencyToken()],
|
|
346
244
|
});
|
|
347
245
|
let body;
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
hostname,
|
|
351
|
-
port,
|
|
352
|
-
method: "DELETE",
|
|
353
|
-
headers,
|
|
354
|
-
path: resolvedPath,
|
|
355
|
-
query,
|
|
356
|
-
body,
|
|
357
|
-
});
|
|
246
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
247
|
+
return b.build();
|
|
358
248
|
};
|
|
359
249
|
export const se_DeleteKxScalingGroupCommand = async (input, context) => {
|
|
360
|
-
const
|
|
250
|
+
const b = rb(input, context);
|
|
361
251
|
const headers = {};
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
|
|
252
|
+
b.bp("/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}");
|
|
253
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
254
|
+
b.p("scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
|
|
366
255
|
const query = map({
|
|
367
|
-
|
|
256
|
+
[_cT]: [, input[_cT] ?? generateIdempotencyToken()],
|
|
368
257
|
});
|
|
369
258
|
let body;
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
hostname,
|
|
373
|
-
port,
|
|
374
|
-
method: "DELETE",
|
|
375
|
-
headers,
|
|
376
|
-
path: resolvedPath,
|
|
377
|
-
query,
|
|
378
|
-
body,
|
|
379
|
-
});
|
|
259
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
260
|
+
return b.build();
|
|
380
261
|
};
|
|
381
262
|
export const se_DeleteKxUserCommand = async (input, context) => {
|
|
382
|
-
const
|
|
263
|
+
const b = rb(input, context);
|
|
383
264
|
const headers = {};
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
265
|
+
b.bp("/kx/environments/{environmentId}/users/{userName}");
|
|
266
|
+
b.p("userName", () => input.userName, "{userName}", false);
|
|
267
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
388
268
|
const query = map({
|
|
389
|
-
|
|
269
|
+
[_cT]: [, input[_cT] ?? generateIdempotencyToken()],
|
|
390
270
|
});
|
|
391
271
|
let body;
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
hostname,
|
|
395
|
-
port,
|
|
396
|
-
method: "DELETE",
|
|
397
|
-
headers,
|
|
398
|
-
path: resolvedPath,
|
|
399
|
-
query,
|
|
400
|
-
body,
|
|
401
|
-
});
|
|
272
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
273
|
+
return b.build();
|
|
402
274
|
};
|
|
403
275
|
export const se_DeleteKxVolumeCommand = async (input, context) => {
|
|
404
|
-
const
|
|
276
|
+
const b = rb(input, context);
|
|
405
277
|
const headers = {};
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
|
|
278
|
+
b.bp("/kx/environments/{environmentId}/kxvolumes/{volumeName}");
|
|
279
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
280
|
+
b.p("volumeName", () => input.volumeName, "{volumeName}", false);
|
|
410
281
|
const query = map({
|
|
411
|
-
|
|
282
|
+
[_cT]: [, input[_cT] ?? generateIdempotencyToken()],
|
|
412
283
|
});
|
|
413
284
|
let body;
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
hostname,
|
|
417
|
-
port,
|
|
418
|
-
method: "DELETE",
|
|
419
|
-
headers,
|
|
420
|
-
path: resolvedPath,
|
|
421
|
-
query,
|
|
422
|
-
body,
|
|
423
|
-
});
|
|
285
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
286
|
+
return b.build();
|
|
424
287
|
};
|
|
425
288
|
export const se_GetEnvironmentCommand = async (input, context) => {
|
|
426
|
-
const
|
|
289
|
+
const b = rb(input, context);
|
|
427
290
|
const headers = {};
|
|
428
|
-
|
|
429
|
-
|
|
291
|
+
b.bp("/environment/{environmentId}");
|
|
292
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
430
293
|
let body;
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
hostname,
|
|
434
|
-
port,
|
|
435
|
-
method: "GET",
|
|
436
|
-
headers,
|
|
437
|
-
path: resolvedPath,
|
|
438
|
-
body,
|
|
439
|
-
});
|
|
294
|
+
b.m("GET").h(headers).b(body);
|
|
295
|
+
return b.build();
|
|
440
296
|
};
|
|
441
297
|
export const se_GetKxChangesetCommand = async (input, context) => {
|
|
442
|
-
const
|
|
298
|
+
const b = rb(input, context);
|
|
443
299
|
const headers = {};
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "changesetId", () => input.changesetId, "{changesetId}", false);
|
|
300
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/changesets/{changesetId}");
|
|
301
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
302
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
303
|
+
b.p("changesetId", () => input.changesetId, "{changesetId}", false);
|
|
449
304
|
let body;
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
hostname,
|
|
453
|
-
port,
|
|
454
|
-
method: "GET",
|
|
455
|
-
headers,
|
|
456
|
-
path: resolvedPath,
|
|
457
|
-
body,
|
|
458
|
-
});
|
|
305
|
+
b.m("GET").h(headers).b(body);
|
|
306
|
+
return b.build();
|
|
459
307
|
};
|
|
460
308
|
export const se_GetKxClusterCommand = async (input, context) => {
|
|
461
|
-
const
|
|
309
|
+
const b = rb(input, context);
|
|
462
310
|
const headers = {};
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
|
|
311
|
+
b.bp("/kx/environments/{environmentId}/clusters/{clusterName}");
|
|
312
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
313
|
+
b.p("clusterName", () => input.clusterName, "{clusterName}", false);
|
|
467
314
|
let body;
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
hostname,
|
|
471
|
-
port,
|
|
472
|
-
method: "GET",
|
|
473
|
-
headers,
|
|
474
|
-
path: resolvedPath,
|
|
475
|
-
body,
|
|
476
|
-
});
|
|
315
|
+
b.m("GET").h(headers).b(body);
|
|
316
|
+
return b.build();
|
|
477
317
|
};
|
|
478
318
|
export const se_GetKxConnectionStringCommand = async (input, context) => {
|
|
479
|
-
const
|
|
319
|
+
const b = rb(input, context);
|
|
480
320
|
const headers = {};
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
321
|
+
b.bp("/kx/environments/{environmentId}/connectionString");
|
|
322
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
484
323
|
const query = map({
|
|
485
|
-
|
|
486
|
-
|
|
324
|
+
[_uA]: [, __expectNonNull(input[_uA], `userArn`)],
|
|
325
|
+
[_cN]: [, __expectNonNull(input[_cN], `clusterName`)],
|
|
487
326
|
});
|
|
488
327
|
let body;
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
hostname,
|
|
492
|
-
port,
|
|
493
|
-
method: "GET",
|
|
494
|
-
headers,
|
|
495
|
-
path: resolvedPath,
|
|
496
|
-
query,
|
|
497
|
-
body,
|
|
498
|
-
});
|
|
328
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
329
|
+
return b.build();
|
|
499
330
|
};
|
|
500
331
|
export const se_GetKxDatabaseCommand = async (input, context) => {
|
|
501
|
-
const
|
|
332
|
+
const b = rb(input, context);
|
|
502
333
|
const headers = {};
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
334
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}");
|
|
335
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
336
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
507
337
|
let body;
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
hostname,
|
|
511
|
-
port,
|
|
512
|
-
method: "GET",
|
|
513
|
-
headers,
|
|
514
|
-
path: resolvedPath,
|
|
515
|
-
body,
|
|
516
|
-
});
|
|
338
|
+
b.m("GET").h(headers).b(body);
|
|
339
|
+
return b.build();
|
|
517
340
|
};
|
|
518
341
|
export const se_GetKxDataviewCommand = async (input, context) => {
|
|
519
|
-
const
|
|
342
|
+
const b = rb(input, context);
|
|
520
343
|
const headers = {};
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
344
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}");
|
|
345
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
346
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
347
|
+
b.p("dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
526
348
|
let body;
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
hostname,
|
|
530
|
-
port,
|
|
531
|
-
method: "GET",
|
|
532
|
-
headers,
|
|
533
|
-
path: resolvedPath,
|
|
534
|
-
body,
|
|
535
|
-
});
|
|
349
|
+
b.m("GET").h(headers).b(body);
|
|
350
|
+
return b.build();
|
|
536
351
|
};
|
|
537
352
|
export const se_GetKxEnvironmentCommand = async (input, context) => {
|
|
538
|
-
const
|
|
353
|
+
const b = rb(input, context);
|
|
539
354
|
const headers = {};
|
|
540
|
-
|
|
541
|
-
|
|
355
|
+
b.bp("/kx/environments/{environmentId}");
|
|
356
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
542
357
|
let body;
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
hostname,
|
|
546
|
-
port,
|
|
547
|
-
method: "GET",
|
|
548
|
-
headers,
|
|
549
|
-
path: resolvedPath,
|
|
550
|
-
body,
|
|
551
|
-
});
|
|
358
|
+
b.m("GET").h(headers).b(body);
|
|
359
|
+
return b.build();
|
|
552
360
|
};
|
|
553
361
|
export const se_GetKxScalingGroupCommand = async (input, context) => {
|
|
554
|
-
const
|
|
362
|
+
const b = rb(input, context);
|
|
555
363
|
const headers = {};
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
|
|
364
|
+
b.bp("/kx/environments/{environmentId}/scalingGroups/{scalingGroupName}");
|
|
365
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
366
|
+
b.p("scalingGroupName", () => input.scalingGroupName, "{scalingGroupName}", false);
|
|
560
367
|
let body;
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
hostname,
|
|
564
|
-
port,
|
|
565
|
-
method: "GET",
|
|
566
|
-
headers,
|
|
567
|
-
path: resolvedPath,
|
|
568
|
-
body,
|
|
569
|
-
});
|
|
368
|
+
b.m("GET").h(headers).b(body);
|
|
369
|
+
return b.build();
|
|
570
370
|
};
|
|
571
371
|
export const se_GetKxUserCommand = async (input, context) => {
|
|
572
|
-
const
|
|
372
|
+
const b = rb(input, context);
|
|
573
373
|
const headers = {};
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
374
|
+
b.bp("/kx/environments/{environmentId}/users/{userName}");
|
|
375
|
+
b.p("userName", () => input.userName, "{userName}", false);
|
|
376
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
578
377
|
let body;
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
hostname,
|
|
582
|
-
port,
|
|
583
|
-
method: "GET",
|
|
584
|
-
headers,
|
|
585
|
-
path: resolvedPath,
|
|
586
|
-
body,
|
|
587
|
-
});
|
|
378
|
+
b.m("GET").h(headers).b(body);
|
|
379
|
+
return b.build();
|
|
588
380
|
};
|
|
589
381
|
export const se_GetKxVolumeCommand = async (input, context) => {
|
|
590
|
-
const
|
|
382
|
+
const b = rb(input, context);
|
|
591
383
|
const headers = {};
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
|
|
384
|
+
b.bp("/kx/environments/{environmentId}/kxvolumes/{volumeName}");
|
|
385
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
386
|
+
b.p("volumeName", () => input.volumeName, "{volumeName}", false);
|
|
596
387
|
let body;
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
hostname,
|
|
600
|
-
port,
|
|
601
|
-
method: "GET",
|
|
602
|
-
headers,
|
|
603
|
-
path: resolvedPath,
|
|
604
|
-
body,
|
|
605
|
-
});
|
|
388
|
+
b.m("GET").h(headers).b(body);
|
|
389
|
+
return b.build();
|
|
606
390
|
};
|
|
607
391
|
export const se_ListEnvironmentsCommand = async (input, context) => {
|
|
608
|
-
const
|
|
392
|
+
const b = rb(input, context);
|
|
609
393
|
const headers = {};
|
|
610
|
-
|
|
394
|
+
b.bp("/environment");
|
|
611
395
|
const query = map({
|
|
612
|
-
|
|
613
|
-
|
|
396
|
+
[_nT]: [, input[_nT]],
|
|
397
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
614
398
|
});
|
|
615
399
|
let body;
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
hostname,
|
|
619
|
-
port,
|
|
620
|
-
method: "GET",
|
|
621
|
-
headers,
|
|
622
|
-
path: resolvedPath,
|
|
623
|
-
query,
|
|
624
|
-
body,
|
|
625
|
-
});
|
|
400
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
401
|
+
return b.build();
|
|
626
402
|
};
|
|
627
403
|
export const se_ListKxChangesetsCommand = async (input, context) => {
|
|
628
|
-
const
|
|
404
|
+
const b = rb(input, context);
|
|
629
405
|
const headers = {};
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
406
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/changesets");
|
|
407
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
408
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
634
409
|
const query = map({
|
|
635
|
-
|
|
636
|
-
|
|
410
|
+
[_nT]: [, input[_nT]],
|
|
411
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
637
412
|
});
|
|
638
413
|
let body;
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
hostname,
|
|
642
|
-
port,
|
|
643
|
-
method: "GET",
|
|
644
|
-
headers,
|
|
645
|
-
path: resolvedPath,
|
|
646
|
-
query,
|
|
647
|
-
body,
|
|
648
|
-
});
|
|
414
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
415
|
+
return b.build();
|
|
649
416
|
};
|
|
650
417
|
export const se_ListKxClusterNodesCommand = async (input, context) => {
|
|
651
|
-
const
|
|
418
|
+
const b = rb(input, context);
|
|
652
419
|
const headers = {};
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
|
|
420
|
+
b.bp("/kx/environments/{environmentId}/clusters/{clusterName}/nodes");
|
|
421
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
422
|
+
b.p("clusterName", () => input.clusterName, "{clusterName}", false);
|
|
657
423
|
const query = map({
|
|
658
|
-
|
|
659
|
-
|
|
424
|
+
[_nT]: [, input[_nT]],
|
|
425
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
660
426
|
});
|
|
661
427
|
let body;
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
hostname,
|
|
665
|
-
port,
|
|
666
|
-
method: "GET",
|
|
667
|
-
headers,
|
|
668
|
-
path: resolvedPath,
|
|
669
|
-
query,
|
|
670
|
-
body,
|
|
671
|
-
});
|
|
428
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
429
|
+
return b.build();
|
|
672
430
|
};
|
|
673
431
|
export const se_ListKxClustersCommand = async (input, context) => {
|
|
674
|
-
const
|
|
432
|
+
const b = rb(input, context);
|
|
675
433
|
const headers = {};
|
|
676
|
-
|
|
677
|
-
|
|
434
|
+
b.bp("/kx/environments/{environmentId}/clusters");
|
|
435
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
678
436
|
const query = map({
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
437
|
+
[_cTl]: [, input[_cTl]],
|
|
438
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
439
|
+
[_nT]: [, input[_nT]],
|
|
682
440
|
});
|
|
683
441
|
let body;
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
hostname,
|
|
687
|
-
port,
|
|
688
|
-
method: "GET",
|
|
689
|
-
headers,
|
|
690
|
-
path: resolvedPath,
|
|
691
|
-
query,
|
|
692
|
-
body,
|
|
693
|
-
});
|
|
442
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
443
|
+
return b.build();
|
|
694
444
|
};
|
|
695
445
|
export const se_ListKxDatabasesCommand = async (input, context) => {
|
|
696
|
-
const
|
|
446
|
+
const b = rb(input, context);
|
|
697
447
|
const headers = {};
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
448
|
+
b.bp("/kx/environments/{environmentId}/databases");
|
|
449
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
701
450
|
const query = map({
|
|
702
|
-
|
|
703
|
-
|
|
451
|
+
[_nT]: [, input[_nT]],
|
|
452
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
704
453
|
});
|
|
705
454
|
let body;
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
hostname,
|
|
709
|
-
port,
|
|
710
|
-
method: "GET",
|
|
711
|
-
headers,
|
|
712
|
-
path: resolvedPath,
|
|
713
|
-
query,
|
|
714
|
-
body,
|
|
715
|
-
});
|
|
455
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
456
|
+
return b.build();
|
|
716
457
|
};
|
|
717
458
|
export const se_ListKxDataviewsCommand = async (input, context) => {
|
|
718
|
-
const
|
|
459
|
+
const b = rb(input, context);
|
|
719
460
|
const headers = {};
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
461
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/dataviews");
|
|
462
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
463
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
724
464
|
const query = map({
|
|
725
|
-
|
|
726
|
-
|
|
465
|
+
[_nT]: [, input[_nT]],
|
|
466
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
727
467
|
});
|
|
728
468
|
let body;
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
hostname,
|
|
732
|
-
port,
|
|
733
|
-
method: "GET",
|
|
734
|
-
headers,
|
|
735
|
-
path: resolvedPath,
|
|
736
|
-
query,
|
|
737
|
-
body,
|
|
738
|
-
});
|
|
469
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
470
|
+
return b.build();
|
|
739
471
|
};
|
|
740
472
|
export const se_ListKxEnvironmentsCommand = async (input, context) => {
|
|
741
|
-
const
|
|
473
|
+
const b = rb(input, context);
|
|
742
474
|
const headers = {};
|
|
743
|
-
|
|
475
|
+
b.bp("/kx/environments");
|
|
744
476
|
const query = map({
|
|
745
|
-
|
|
746
|
-
|
|
477
|
+
[_nT]: [, input[_nT]],
|
|
478
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
747
479
|
});
|
|
748
480
|
let body;
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
hostname,
|
|
752
|
-
port,
|
|
753
|
-
method: "GET",
|
|
754
|
-
headers,
|
|
755
|
-
path: resolvedPath,
|
|
756
|
-
query,
|
|
757
|
-
body,
|
|
758
|
-
});
|
|
481
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
482
|
+
return b.build();
|
|
759
483
|
};
|
|
760
484
|
export const se_ListKxScalingGroupsCommand = async (input, context) => {
|
|
761
|
-
const
|
|
485
|
+
const b = rb(input, context);
|
|
762
486
|
const headers = {};
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
487
|
+
b.bp("/kx/environments/{environmentId}/scalingGroups");
|
|
488
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
766
489
|
const query = map({
|
|
767
|
-
|
|
768
|
-
|
|
490
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
491
|
+
[_nT]: [, input[_nT]],
|
|
769
492
|
});
|
|
770
493
|
let body;
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
hostname,
|
|
774
|
-
port,
|
|
775
|
-
method: "GET",
|
|
776
|
-
headers,
|
|
777
|
-
path: resolvedPath,
|
|
778
|
-
query,
|
|
779
|
-
body,
|
|
780
|
-
});
|
|
494
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
495
|
+
return b.build();
|
|
781
496
|
};
|
|
782
497
|
export const se_ListKxUsersCommand = async (input, context) => {
|
|
783
|
-
const
|
|
498
|
+
const b = rb(input, context);
|
|
784
499
|
const headers = {};
|
|
785
|
-
|
|
786
|
-
|
|
500
|
+
b.bp("/kx/environments/{environmentId}/users");
|
|
501
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
787
502
|
const query = map({
|
|
788
|
-
|
|
789
|
-
|
|
503
|
+
[_nT]: [, input[_nT]],
|
|
504
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
790
505
|
});
|
|
791
506
|
let body;
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
hostname,
|
|
795
|
-
port,
|
|
796
|
-
method: "GET",
|
|
797
|
-
headers,
|
|
798
|
-
path: resolvedPath,
|
|
799
|
-
query,
|
|
800
|
-
body,
|
|
801
|
-
});
|
|
507
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
508
|
+
return b.build();
|
|
802
509
|
};
|
|
803
510
|
export const se_ListKxVolumesCommand = async (input, context) => {
|
|
804
|
-
const
|
|
511
|
+
const b = rb(input, context);
|
|
805
512
|
const headers = {};
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "environmentId", () => input.environmentId, "{environmentId}", false);
|
|
513
|
+
b.bp("/kx/environments/{environmentId}/kxvolumes");
|
|
514
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
809
515
|
const query = map({
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
516
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
517
|
+
[_nT]: [, input[_nT]],
|
|
518
|
+
[_vT]: [, input[_vT]],
|
|
813
519
|
});
|
|
814
520
|
let body;
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
hostname,
|
|
818
|
-
port,
|
|
819
|
-
method: "GET",
|
|
820
|
-
headers,
|
|
821
|
-
path: resolvedPath,
|
|
822
|
-
query,
|
|
823
|
-
body,
|
|
824
|
-
});
|
|
521
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
522
|
+
return b.build();
|
|
825
523
|
};
|
|
826
524
|
export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
827
|
-
const
|
|
525
|
+
const b = rb(input, context);
|
|
828
526
|
const headers = {};
|
|
829
|
-
|
|
830
|
-
|
|
527
|
+
b.bp("/tags/{resourceArn}");
|
|
528
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
831
529
|
let body;
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
hostname,
|
|
835
|
-
port,
|
|
836
|
-
method: "GET",
|
|
837
|
-
headers,
|
|
838
|
-
path: resolvedPath,
|
|
839
|
-
body,
|
|
840
|
-
});
|
|
530
|
+
b.m("GET").h(headers).b(body);
|
|
531
|
+
return b.build();
|
|
841
532
|
};
|
|
842
533
|
export const se_TagResourceCommand = async (input, context) => {
|
|
843
|
-
const
|
|
534
|
+
const b = rb(input, context);
|
|
844
535
|
const headers = {
|
|
845
536
|
"content-type": "application/json",
|
|
846
537
|
};
|
|
847
|
-
|
|
848
|
-
|
|
538
|
+
b.bp("/tags/{resourceArn}");
|
|
539
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
849
540
|
let body;
|
|
850
541
|
body = JSON.stringify(take(input, {
|
|
851
542
|
tags: (_) => _json(_),
|
|
852
543
|
}));
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
hostname,
|
|
856
|
-
port,
|
|
857
|
-
method: "POST",
|
|
858
|
-
headers,
|
|
859
|
-
path: resolvedPath,
|
|
860
|
-
body,
|
|
861
|
-
});
|
|
544
|
+
b.m("POST").h(headers).b(body);
|
|
545
|
+
return b.build();
|
|
862
546
|
};
|
|
863
547
|
export const se_UntagResourceCommand = async (input, context) => {
|
|
864
|
-
const
|
|
548
|
+
const b = rb(input, context);
|
|
865
549
|
const headers = {};
|
|
866
|
-
|
|
867
|
-
|
|
550
|
+
b.bp("/tags/{resourceArn}");
|
|
551
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
868
552
|
const query = map({
|
|
869
|
-
|
|
553
|
+
[_tK]: [
|
|
870
554
|
__expectNonNull(input.tagKeys, `tagKeys`) != null,
|
|
871
|
-
() => (input
|
|
555
|
+
() => (input[_tK] || []).map((_entry) => _entry),
|
|
872
556
|
],
|
|
873
557
|
});
|
|
874
558
|
let body;
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
hostname,
|
|
878
|
-
port,
|
|
879
|
-
method: "DELETE",
|
|
880
|
-
headers,
|
|
881
|
-
path: resolvedPath,
|
|
882
|
-
query,
|
|
883
|
-
body,
|
|
884
|
-
});
|
|
559
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
560
|
+
return b.build();
|
|
885
561
|
};
|
|
886
562
|
export const se_UpdateEnvironmentCommand = async (input, context) => {
|
|
887
|
-
const
|
|
563
|
+
const b = rb(input, context);
|
|
888
564
|
const headers = {
|
|
889
565
|
"content-type": "application/json",
|
|
890
566
|
};
|
|
891
|
-
|
|
892
|
-
|
|
567
|
+
b.bp("/environment/{environmentId}");
|
|
568
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
893
569
|
let body;
|
|
894
570
|
body = JSON.stringify(take(input, {
|
|
895
571
|
description: [],
|
|
@@ -897,25 +573,17 @@ export const se_UpdateEnvironmentCommand = async (input, context) => {
|
|
|
897
573
|
federationParameters: (_) => _json(_),
|
|
898
574
|
name: [],
|
|
899
575
|
}));
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
hostname,
|
|
903
|
-
port,
|
|
904
|
-
method: "PUT",
|
|
905
|
-
headers,
|
|
906
|
-
path: resolvedPath,
|
|
907
|
-
body,
|
|
908
|
-
});
|
|
576
|
+
b.m("PUT").h(headers).b(body);
|
|
577
|
+
return b.build();
|
|
909
578
|
};
|
|
910
579
|
export const se_UpdateKxClusterCodeConfigurationCommand = async (input, context) => {
|
|
911
|
-
const
|
|
580
|
+
const b = rb(input, context);
|
|
912
581
|
const headers = {
|
|
913
582
|
"content-type": "application/json",
|
|
914
583
|
};
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
|
|
584
|
+
b.bp("/kx/environments/{environmentId}/clusters/{clusterName}/configuration/code");
|
|
585
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
586
|
+
b.p("clusterName", () => input.clusterName, "{clusterName}", false);
|
|
919
587
|
let body;
|
|
920
588
|
body = JSON.stringify(take(input, {
|
|
921
589
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -924,75 +592,51 @@ export const se_UpdateKxClusterCodeConfigurationCommand = async (input, context)
|
|
|
924
592
|
deploymentConfiguration: (_) => _json(_),
|
|
925
593
|
initializationScript: [],
|
|
926
594
|
}));
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
hostname,
|
|
930
|
-
port,
|
|
931
|
-
method: "PUT",
|
|
932
|
-
headers,
|
|
933
|
-
path: resolvedPath,
|
|
934
|
-
body,
|
|
935
|
-
});
|
|
595
|
+
b.m("PUT").h(headers).b(body);
|
|
596
|
+
return b.build();
|
|
936
597
|
};
|
|
937
598
|
export const se_UpdateKxClusterDatabasesCommand = async (input, context) => {
|
|
938
|
-
const
|
|
599
|
+
const b = rb(input, context);
|
|
939
600
|
const headers = {
|
|
940
601
|
"content-type": "application/json",
|
|
941
602
|
};
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "clusterName", () => input.clusterName, "{clusterName}", false);
|
|
603
|
+
b.bp("/kx/environments/{environmentId}/clusters/{clusterName}/configuration/databases");
|
|
604
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
605
|
+
b.p("clusterName", () => input.clusterName, "{clusterName}", false);
|
|
946
606
|
let body;
|
|
947
607
|
body = JSON.stringify(take(input, {
|
|
948
608
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
949
609
|
databases: (_) => _json(_),
|
|
950
610
|
deploymentConfiguration: (_) => _json(_),
|
|
951
611
|
}));
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
hostname,
|
|
955
|
-
port,
|
|
956
|
-
method: "PUT",
|
|
957
|
-
headers,
|
|
958
|
-
path: resolvedPath,
|
|
959
|
-
body,
|
|
960
|
-
});
|
|
612
|
+
b.m("PUT").h(headers).b(body);
|
|
613
|
+
return b.build();
|
|
961
614
|
};
|
|
962
615
|
export const se_UpdateKxDatabaseCommand = async (input, context) => {
|
|
963
|
-
const
|
|
616
|
+
const b = rb(input, context);
|
|
964
617
|
const headers = {
|
|
965
618
|
"content-type": "application/json",
|
|
966
619
|
};
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "databaseName", () => input.databaseName, "{databaseName}", false);
|
|
620
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}");
|
|
621
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
622
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
971
623
|
let body;
|
|
972
624
|
body = JSON.stringify(take(input, {
|
|
973
625
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
974
626
|
description: [],
|
|
975
627
|
}));
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
hostname,
|
|
979
|
-
port,
|
|
980
|
-
method: "PUT",
|
|
981
|
-
headers,
|
|
982
|
-
path: resolvedPath,
|
|
983
|
-
body,
|
|
984
|
-
});
|
|
628
|
+
b.m("PUT").h(headers).b(body);
|
|
629
|
+
return b.build();
|
|
985
630
|
};
|
|
986
631
|
export const se_UpdateKxDataviewCommand = async (input, context) => {
|
|
987
|
-
const
|
|
632
|
+
const b = rb(input, context);
|
|
988
633
|
const headers = {
|
|
989
634
|
"content-type": "application/json",
|
|
990
635
|
};
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
636
|
+
b.bp("/kx/environments/{environmentId}/databases/{databaseName}/dataviews/{dataviewName}");
|
|
637
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
638
|
+
b.p("databaseName", () => input.databaseName, "{databaseName}", false);
|
|
639
|
+
b.p("dataviewName", () => input.dataviewName, "{dataviewName}", false);
|
|
996
640
|
let body;
|
|
997
641
|
body = JSON.stringify(take(input, {
|
|
998
642
|
changesetId: [],
|
|
@@ -1000,110 +644,73 @@ export const se_UpdateKxDataviewCommand = async (input, context) => {
|
|
|
1000
644
|
description: [],
|
|
1001
645
|
segmentConfigurations: (_) => _json(_),
|
|
1002
646
|
}));
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
hostname,
|
|
1006
|
-
port,
|
|
1007
|
-
method: "PUT",
|
|
1008
|
-
headers,
|
|
1009
|
-
path: resolvedPath,
|
|
1010
|
-
body,
|
|
1011
|
-
});
|
|
647
|
+
b.m("PUT").h(headers).b(body);
|
|
648
|
+
return b.build();
|
|
1012
649
|
};
|
|
1013
650
|
export const se_UpdateKxEnvironmentCommand = async (input, context) => {
|
|
1014
|
-
const
|
|
651
|
+
const b = rb(input, context);
|
|
1015
652
|
const headers = {
|
|
1016
653
|
"content-type": "application/json",
|
|
1017
654
|
};
|
|
1018
|
-
|
|
1019
|
-
|
|
655
|
+
b.bp("/kx/environments/{environmentId}");
|
|
656
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
1020
657
|
let body;
|
|
1021
658
|
body = JSON.stringify(take(input, {
|
|
1022
659
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
1023
660
|
description: [],
|
|
1024
661
|
name: [],
|
|
1025
662
|
}));
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
hostname,
|
|
1029
|
-
port,
|
|
1030
|
-
method: "PUT",
|
|
1031
|
-
headers,
|
|
1032
|
-
path: resolvedPath,
|
|
1033
|
-
body,
|
|
1034
|
-
});
|
|
663
|
+
b.m("PUT").h(headers).b(body);
|
|
664
|
+
return b.build();
|
|
1035
665
|
};
|
|
1036
666
|
export const se_UpdateKxEnvironmentNetworkCommand = async (input, context) => {
|
|
1037
|
-
const
|
|
667
|
+
const b = rb(input, context);
|
|
1038
668
|
const headers = {
|
|
1039
669
|
"content-type": "application/json",
|
|
1040
670
|
};
|
|
1041
|
-
|
|
1042
|
-
|
|
671
|
+
b.bp("/kx/environments/{environmentId}/network");
|
|
672
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
1043
673
|
let body;
|
|
1044
674
|
body = JSON.stringify(take(input, {
|
|
1045
675
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
1046
676
|
customDNSConfiguration: (_) => _json(_),
|
|
1047
677
|
transitGatewayConfiguration: (_) => _json(_),
|
|
1048
678
|
}));
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
hostname,
|
|
1052
|
-
port,
|
|
1053
|
-
method: "PUT",
|
|
1054
|
-
headers,
|
|
1055
|
-
path: resolvedPath,
|
|
1056
|
-
body,
|
|
1057
|
-
});
|
|
679
|
+
b.m("PUT").h(headers).b(body);
|
|
680
|
+
return b.build();
|
|
1058
681
|
};
|
|
1059
682
|
export const se_UpdateKxUserCommand = async (input, context) => {
|
|
1060
|
-
const
|
|
683
|
+
const b = rb(input, context);
|
|
1061
684
|
const headers = {
|
|
1062
685
|
"content-type": "application/json",
|
|
1063
686
|
};
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "userName", () => input.userName, "{userName}", false);
|
|
687
|
+
b.bp("/kx/environments/{environmentId}/users/{userName}");
|
|
688
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
689
|
+
b.p("userName", () => input.userName, "{userName}", false);
|
|
1068
690
|
let body;
|
|
1069
691
|
body = JSON.stringify(take(input, {
|
|
1070
692
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
1071
693
|
iamRole: [],
|
|
1072
694
|
}));
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
hostname,
|
|
1076
|
-
port,
|
|
1077
|
-
method: "PUT",
|
|
1078
|
-
headers,
|
|
1079
|
-
path: resolvedPath,
|
|
1080
|
-
body,
|
|
1081
|
-
});
|
|
695
|
+
b.m("PUT").h(headers).b(body);
|
|
696
|
+
return b.build();
|
|
1082
697
|
};
|
|
1083
698
|
export const se_UpdateKxVolumeCommand = async (input, context) => {
|
|
1084
|
-
const
|
|
699
|
+
const b = rb(input, context);
|
|
1085
700
|
const headers = {
|
|
1086
701
|
"content-type": "application/json",
|
|
1087
702
|
};
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "volumeName", () => input.volumeName, "{volumeName}", false);
|
|
703
|
+
b.bp("/kx/environments/{environmentId}/kxvolumes/{volumeName}");
|
|
704
|
+
b.p("environmentId", () => input.environmentId, "{environmentId}", false);
|
|
705
|
+
b.p("volumeName", () => input.volumeName, "{volumeName}", false);
|
|
1092
706
|
let body;
|
|
1093
707
|
body = JSON.stringify(take(input, {
|
|
1094
708
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
1095
709
|
description: [],
|
|
1096
710
|
nas1Configuration: (_) => _json(_),
|
|
1097
711
|
}));
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
hostname,
|
|
1101
|
-
port,
|
|
1102
|
-
method: "PATCH",
|
|
1103
|
-
headers,
|
|
1104
|
-
path: resolvedPath,
|
|
1105
|
-
body,
|
|
1106
|
-
});
|
|
712
|
+
b.m("PATCH").h(headers).b(body);
|
|
713
|
+
return b.build();
|
|
1107
714
|
};
|
|
1108
715
|
export const de_CreateEnvironmentCommand = async (output, context) => {
|
|
1109
716
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4018,6 +3625,14 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
4018
3625
|
value !== "" &&
|
|
4019
3626
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
4020
3627
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
3628
|
+
const _cN = "clusterName";
|
|
3629
|
+
const _cT = "clientToken";
|
|
3630
|
+
const _cTl = "clusterType";
|
|
3631
|
+
const _mR = "maxResults";
|
|
3632
|
+
const _nT = "nextToken";
|
|
3633
|
+
const _tK = "tagKeys";
|
|
3634
|
+
const _uA = "userArn";
|
|
3635
|
+
const _vT = "volumeType";
|
|
4021
3636
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
4022
3637
|
if (encoded.length) {
|
|
4023
3638
|
return JSON.parse(encoded);
|