@aws-sdk/client-opensearch 3.476.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 +361 -828
- package/dist-es/protocols/Aws_restJson1.js +362 -829
- package/package.json +5 -4
|
@@ -1,137 +1,90 @@
|
|
|
1
1
|
import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
|
|
2
|
-
import {
|
|
3
|
-
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,
|
|
2
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
3
|
+
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, take, withBaseException, } from "@smithy/smithy-client";
|
|
4
4
|
import { AccessDeniedException, BaseException, ConflictException, DependencyFailureException, DisabledOperationException, InternalException, InvalidPaginationTokenException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, SlotNotAvailableException, ValidationException, } from "../models/models_0";
|
|
5
5
|
import { OpenSearchServiceException as __BaseException } from "../models/OpenSearchServiceException";
|
|
6
6
|
export const se_AcceptInboundConnectionCommand = async (input, context) => {
|
|
7
|
-
const
|
|
7
|
+
const b = rb(input, context);
|
|
8
8
|
const headers = {};
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
9
|
+
b.bp("/2021-01-01/opensearch/cc/inboundConnection/{ConnectionId}/accept");
|
|
10
|
+
b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
12
11
|
let body;
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
hostname,
|
|
16
|
-
port,
|
|
17
|
-
method: "PUT",
|
|
18
|
-
headers,
|
|
19
|
-
path: resolvedPath,
|
|
20
|
-
body,
|
|
21
|
-
});
|
|
12
|
+
b.m("PUT").h(headers).b(body);
|
|
13
|
+
return b.build();
|
|
22
14
|
};
|
|
23
15
|
export const se_AddDataSourceCommand = async (input, context) => {
|
|
24
|
-
const
|
|
16
|
+
const b = rb(input, context);
|
|
25
17
|
const headers = {
|
|
26
18
|
"content-type": "application/json",
|
|
27
19
|
};
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
20
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dataSource");
|
|
21
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
31
22
|
let body;
|
|
32
23
|
body = JSON.stringify(take(input, {
|
|
33
24
|
DataSourceType: (_) => _json(_),
|
|
34
25
|
Description: [],
|
|
35
26
|
Name: [],
|
|
36
27
|
}));
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
hostname,
|
|
40
|
-
port,
|
|
41
|
-
method: "POST",
|
|
42
|
-
headers,
|
|
43
|
-
path: resolvedPath,
|
|
44
|
-
body,
|
|
45
|
-
});
|
|
28
|
+
b.m("POST").h(headers).b(body);
|
|
29
|
+
return b.build();
|
|
46
30
|
};
|
|
47
31
|
export const se_AddTagsCommand = async (input, context) => {
|
|
48
|
-
const
|
|
32
|
+
const b = rb(input, context);
|
|
49
33
|
const headers = {
|
|
50
34
|
"content-type": "application/json",
|
|
51
35
|
};
|
|
52
|
-
|
|
36
|
+
b.bp("/2021-01-01/tags");
|
|
53
37
|
let body;
|
|
54
38
|
body = JSON.stringify(take(input, {
|
|
55
39
|
ARN: [],
|
|
56
40
|
TagList: (_) => _json(_),
|
|
57
41
|
}));
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
hostname,
|
|
61
|
-
port,
|
|
62
|
-
method: "POST",
|
|
63
|
-
headers,
|
|
64
|
-
path: resolvedPath,
|
|
65
|
-
body,
|
|
66
|
-
});
|
|
42
|
+
b.m("POST").h(headers).b(body);
|
|
43
|
+
return b.build();
|
|
67
44
|
};
|
|
68
45
|
export const se_AssociatePackageCommand = async (input, context) => {
|
|
69
|
-
const
|
|
46
|
+
const b = rb(input, context);
|
|
70
47
|
const headers = {};
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
48
|
+
b.bp("/2021-01-01/packages/associate/{PackageID}/{DomainName}");
|
|
49
|
+
b.p("PackageID", () => input.PackageID, "{PackageID}", false);
|
|
50
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
75
51
|
let body;
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
hostname,
|
|
79
|
-
port,
|
|
80
|
-
method: "POST",
|
|
81
|
-
headers,
|
|
82
|
-
path: resolvedPath,
|
|
83
|
-
body,
|
|
84
|
-
});
|
|
52
|
+
b.m("POST").h(headers).b(body);
|
|
53
|
+
return b.build();
|
|
85
54
|
};
|
|
86
55
|
export const se_AuthorizeVpcEndpointAccessCommand = async (input, context) => {
|
|
87
|
-
const
|
|
56
|
+
const b = rb(input, context);
|
|
88
57
|
const headers = {
|
|
89
58
|
"content-type": "application/json",
|
|
90
59
|
};
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
60
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/authorizeVpcEndpointAccess");
|
|
61
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
94
62
|
let body;
|
|
95
63
|
body = JSON.stringify(take(input, {
|
|
96
64
|
Account: [],
|
|
97
65
|
}));
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
hostname,
|
|
101
|
-
port,
|
|
102
|
-
method: "POST",
|
|
103
|
-
headers,
|
|
104
|
-
path: resolvedPath,
|
|
105
|
-
body,
|
|
106
|
-
});
|
|
66
|
+
b.m("POST").h(headers).b(body);
|
|
67
|
+
return b.build();
|
|
107
68
|
};
|
|
108
69
|
export const se_CancelServiceSoftwareUpdateCommand = async (input, context) => {
|
|
109
|
-
const
|
|
70
|
+
const b = rb(input, context);
|
|
110
71
|
const headers = {
|
|
111
72
|
"content-type": "application/json",
|
|
112
73
|
};
|
|
113
|
-
|
|
114
|
-
"/2021-01-01/opensearch/serviceSoftwareUpdate/cancel";
|
|
74
|
+
b.bp("/2021-01-01/opensearch/serviceSoftwareUpdate/cancel");
|
|
115
75
|
let body;
|
|
116
76
|
body = JSON.stringify(take(input, {
|
|
117
77
|
DomainName: [],
|
|
118
78
|
}));
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
hostname,
|
|
122
|
-
port,
|
|
123
|
-
method: "POST",
|
|
124
|
-
headers,
|
|
125
|
-
path: resolvedPath,
|
|
126
|
-
body,
|
|
127
|
-
});
|
|
79
|
+
b.m("POST").h(headers).b(body);
|
|
80
|
+
return b.build();
|
|
128
81
|
};
|
|
129
82
|
export const se_CreateDomainCommand = async (input, context) => {
|
|
130
|
-
const
|
|
83
|
+
const b = rb(input, context);
|
|
131
84
|
const headers = {
|
|
132
85
|
"content-type": "application/json",
|
|
133
86
|
};
|
|
134
|
-
|
|
87
|
+
b.bp("/2021-01-01/opensearch/domain");
|
|
135
88
|
let body;
|
|
136
89
|
body = JSON.stringify(take(input, {
|
|
137
90
|
AccessPolicies: [],
|
|
@@ -154,23 +107,15 @@ export const se_CreateDomainCommand = async (input, context) => {
|
|
|
154
107
|
TagList: (_) => _json(_),
|
|
155
108
|
VPCOptions: (_) => _json(_),
|
|
156
109
|
}));
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
hostname,
|
|
160
|
-
port,
|
|
161
|
-
method: "POST",
|
|
162
|
-
headers,
|
|
163
|
-
path: resolvedPath,
|
|
164
|
-
body,
|
|
165
|
-
});
|
|
110
|
+
b.m("POST").h(headers).b(body);
|
|
111
|
+
return b.build();
|
|
166
112
|
};
|
|
167
113
|
export const se_CreateOutboundConnectionCommand = async (input, context) => {
|
|
168
|
-
const
|
|
114
|
+
const b = rb(input, context);
|
|
169
115
|
const headers = {
|
|
170
116
|
"content-type": "application/json",
|
|
171
117
|
};
|
|
172
|
-
|
|
173
|
-
"/2021-01-01/opensearch/cc/outboundConnection";
|
|
118
|
+
b.bp("/2021-01-01/opensearch/cc/outboundConnection");
|
|
174
119
|
let body;
|
|
175
120
|
body = JSON.stringify(take(input, {
|
|
176
121
|
ConnectionAlias: [],
|
|
@@ -179,22 +124,15 @@ export const se_CreateOutboundConnectionCommand = async (input, context) => {
|
|
|
179
124
|
LocalDomainInfo: (_) => _json(_),
|
|
180
125
|
RemoteDomainInfo: (_) => _json(_),
|
|
181
126
|
}));
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
hostname,
|
|
185
|
-
port,
|
|
186
|
-
method: "POST",
|
|
187
|
-
headers,
|
|
188
|
-
path: resolvedPath,
|
|
189
|
-
body,
|
|
190
|
-
});
|
|
127
|
+
b.m("POST").h(headers).b(body);
|
|
128
|
+
return b.build();
|
|
191
129
|
};
|
|
192
130
|
export const se_CreatePackageCommand = async (input, context) => {
|
|
193
|
-
const
|
|
131
|
+
const b = rb(input, context);
|
|
194
132
|
const headers = {
|
|
195
133
|
"content-type": "application/json",
|
|
196
134
|
};
|
|
197
|
-
|
|
135
|
+
b.bp("/2021-01-01/packages");
|
|
198
136
|
let body;
|
|
199
137
|
body = JSON.stringify(take(input, {
|
|
200
138
|
PackageDescription: [],
|
|
@@ -202,994 +140,596 @@ export const se_CreatePackageCommand = async (input, context) => {
|
|
|
202
140
|
PackageSource: (_) => _json(_),
|
|
203
141
|
PackageType: [],
|
|
204
142
|
}));
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
hostname,
|
|
208
|
-
port,
|
|
209
|
-
method: "POST",
|
|
210
|
-
headers,
|
|
211
|
-
path: resolvedPath,
|
|
212
|
-
body,
|
|
213
|
-
});
|
|
143
|
+
b.m("POST").h(headers).b(body);
|
|
144
|
+
return b.build();
|
|
214
145
|
};
|
|
215
146
|
export const se_CreateVpcEndpointCommand = async (input, context) => {
|
|
216
|
-
const
|
|
147
|
+
const b = rb(input, context);
|
|
217
148
|
const headers = {
|
|
218
149
|
"content-type": "application/json",
|
|
219
150
|
};
|
|
220
|
-
|
|
151
|
+
b.bp("/2021-01-01/opensearch/vpcEndpoints");
|
|
221
152
|
let body;
|
|
222
153
|
body = JSON.stringify(take(input, {
|
|
223
154
|
ClientToken: [],
|
|
224
155
|
DomainArn: [],
|
|
225
156
|
VpcOptions: (_) => _json(_),
|
|
226
157
|
}));
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
hostname,
|
|
230
|
-
port,
|
|
231
|
-
method: "POST",
|
|
232
|
-
headers,
|
|
233
|
-
path: resolvedPath,
|
|
234
|
-
body,
|
|
235
|
-
});
|
|
158
|
+
b.m("POST").h(headers).b(body);
|
|
159
|
+
return b.build();
|
|
236
160
|
};
|
|
237
161
|
export const se_DeleteDataSourceCommand = async (input, context) => {
|
|
238
|
-
const
|
|
162
|
+
const b = rb(input, context);
|
|
239
163
|
const headers = {};
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
|
|
164
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}");
|
|
165
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
166
|
+
b.p("Name", () => input.Name, "{Name}", false);
|
|
244
167
|
let body;
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
hostname,
|
|
248
|
-
port,
|
|
249
|
-
method: "DELETE",
|
|
250
|
-
headers,
|
|
251
|
-
path: resolvedPath,
|
|
252
|
-
body,
|
|
253
|
-
});
|
|
168
|
+
b.m("DELETE").h(headers).b(body);
|
|
169
|
+
return b.build();
|
|
254
170
|
};
|
|
255
171
|
export const se_DeleteDomainCommand = async (input, context) => {
|
|
256
|
-
const
|
|
172
|
+
const b = rb(input, context);
|
|
257
173
|
const headers = {};
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
174
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}");
|
|
175
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
261
176
|
let body;
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
hostname,
|
|
265
|
-
port,
|
|
266
|
-
method: "DELETE",
|
|
267
|
-
headers,
|
|
268
|
-
path: resolvedPath,
|
|
269
|
-
body,
|
|
270
|
-
});
|
|
177
|
+
b.m("DELETE").h(headers).b(body);
|
|
178
|
+
return b.build();
|
|
271
179
|
};
|
|
272
180
|
export const se_DeleteInboundConnectionCommand = async (input, context) => {
|
|
273
|
-
const
|
|
181
|
+
const b = rb(input, context);
|
|
274
182
|
const headers = {};
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
183
|
+
b.bp("/2021-01-01/opensearch/cc/inboundConnection/{ConnectionId}");
|
|
184
|
+
b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
278
185
|
let body;
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
hostname,
|
|
282
|
-
port,
|
|
283
|
-
method: "DELETE",
|
|
284
|
-
headers,
|
|
285
|
-
path: resolvedPath,
|
|
286
|
-
body,
|
|
287
|
-
});
|
|
186
|
+
b.m("DELETE").h(headers).b(body);
|
|
187
|
+
return b.build();
|
|
288
188
|
};
|
|
289
189
|
export const se_DeleteOutboundConnectionCommand = async (input, context) => {
|
|
290
|
-
const
|
|
190
|
+
const b = rb(input, context);
|
|
291
191
|
const headers = {};
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
192
|
+
b.bp("/2021-01-01/opensearch/cc/outboundConnection/{ConnectionId}");
|
|
193
|
+
b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
295
194
|
let body;
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
hostname,
|
|
299
|
-
port,
|
|
300
|
-
method: "DELETE",
|
|
301
|
-
headers,
|
|
302
|
-
path: resolvedPath,
|
|
303
|
-
body,
|
|
304
|
-
});
|
|
195
|
+
b.m("DELETE").h(headers).b(body);
|
|
196
|
+
return b.build();
|
|
305
197
|
};
|
|
306
198
|
export const se_DeletePackageCommand = async (input, context) => {
|
|
307
|
-
const
|
|
199
|
+
const b = rb(input, context);
|
|
308
200
|
const headers = {};
|
|
309
|
-
|
|
310
|
-
|
|
201
|
+
b.bp("/2021-01-01/packages/{PackageID}");
|
|
202
|
+
b.p("PackageID", () => input.PackageID, "{PackageID}", false);
|
|
311
203
|
let body;
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
hostname,
|
|
315
|
-
port,
|
|
316
|
-
method: "DELETE",
|
|
317
|
-
headers,
|
|
318
|
-
path: resolvedPath,
|
|
319
|
-
body,
|
|
320
|
-
});
|
|
204
|
+
b.m("DELETE").h(headers).b(body);
|
|
205
|
+
return b.build();
|
|
321
206
|
};
|
|
322
207
|
export const se_DeleteVpcEndpointCommand = async (input, context) => {
|
|
323
|
-
const
|
|
208
|
+
const b = rb(input, context);
|
|
324
209
|
const headers = {};
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "VpcEndpointId", () => input.VpcEndpointId, "{VpcEndpointId}", false);
|
|
210
|
+
b.bp("/2021-01-01/opensearch/vpcEndpoints/{VpcEndpointId}");
|
|
211
|
+
b.p("VpcEndpointId", () => input.VpcEndpointId, "{VpcEndpointId}", false);
|
|
328
212
|
let body;
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
hostname,
|
|
332
|
-
port,
|
|
333
|
-
method: "DELETE",
|
|
334
|
-
headers,
|
|
335
|
-
path: resolvedPath,
|
|
336
|
-
body,
|
|
337
|
-
});
|
|
213
|
+
b.m("DELETE").h(headers).b(body);
|
|
214
|
+
return b.build();
|
|
338
215
|
};
|
|
339
216
|
export const se_DescribeDomainCommand = async (input, context) => {
|
|
340
|
-
const
|
|
217
|
+
const b = rb(input, context);
|
|
341
218
|
const headers = {};
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
219
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}");
|
|
220
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
345
221
|
let body;
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
hostname,
|
|
349
|
-
port,
|
|
350
|
-
method: "GET",
|
|
351
|
-
headers,
|
|
352
|
-
path: resolvedPath,
|
|
353
|
-
body,
|
|
354
|
-
});
|
|
222
|
+
b.m("GET").h(headers).b(body);
|
|
223
|
+
return b.build();
|
|
355
224
|
};
|
|
356
225
|
export const se_DescribeDomainAutoTunesCommand = async (input, context) => {
|
|
357
|
-
const
|
|
226
|
+
const b = rb(input, context);
|
|
358
227
|
const headers = {
|
|
359
228
|
"content-type": "application/json",
|
|
360
229
|
};
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
230
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/autoTunes");
|
|
231
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
364
232
|
let body;
|
|
365
233
|
body = JSON.stringify(take(input, {
|
|
366
234
|
MaxResults: [],
|
|
367
235
|
NextToken: [],
|
|
368
236
|
}));
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
hostname,
|
|
372
|
-
port,
|
|
373
|
-
method: "GET",
|
|
374
|
-
headers,
|
|
375
|
-
path: resolvedPath,
|
|
376
|
-
body,
|
|
377
|
-
});
|
|
237
|
+
b.m("GET").h(headers).b(body);
|
|
238
|
+
return b.build();
|
|
378
239
|
};
|
|
379
240
|
export const se_DescribeDomainChangeProgressCommand = async (input, context) => {
|
|
380
|
-
const
|
|
241
|
+
const b = rb(input, context);
|
|
381
242
|
const headers = {};
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
243
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/progress");
|
|
244
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
385
245
|
const query = map({
|
|
386
|
-
|
|
246
|
+
[_c]: [, input[_CI]],
|
|
387
247
|
});
|
|
388
248
|
let body;
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
hostname,
|
|
392
|
-
port,
|
|
393
|
-
method: "GET",
|
|
394
|
-
headers,
|
|
395
|
-
path: resolvedPath,
|
|
396
|
-
query,
|
|
397
|
-
body,
|
|
398
|
-
});
|
|
249
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
250
|
+
return b.build();
|
|
399
251
|
};
|
|
400
252
|
export const se_DescribeDomainConfigCommand = async (input, context) => {
|
|
401
|
-
const
|
|
253
|
+
const b = rb(input, context);
|
|
402
254
|
const headers = {};
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
255
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/config");
|
|
256
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
406
257
|
let body;
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
hostname,
|
|
410
|
-
port,
|
|
411
|
-
method: "GET",
|
|
412
|
-
headers,
|
|
413
|
-
path: resolvedPath,
|
|
414
|
-
body,
|
|
415
|
-
});
|
|
258
|
+
b.m("GET").h(headers).b(body);
|
|
259
|
+
return b.build();
|
|
416
260
|
};
|
|
417
261
|
export const se_DescribeDomainHealthCommand = async (input, context) => {
|
|
418
|
-
const
|
|
262
|
+
const b = rb(input, context);
|
|
419
263
|
const headers = {};
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
264
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/health");
|
|
265
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
423
266
|
let body;
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
hostname,
|
|
427
|
-
port,
|
|
428
|
-
method: "GET",
|
|
429
|
-
headers,
|
|
430
|
-
path: resolvedPath,
|
|
431
|
-
body,
|
|
432
|
-
});
|
|
267
|
+
b.m("GET").h(headers).b(body);
|
|
268
|
+
return b.build();
|
|
433
269
|
};
|
|
434
270
|
export const se_DescribeDomainNodesCommand = async (input, context) => {
|
|
435
|
-
const
|
|
271
|
+
const b = rb(input, context);
|
|
436
272
|
const headers = {};
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
273
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/nodes");
|
|
274
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
440
275
|
let body;
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
hostname,
|
|
444
|
-
port,
|
|
445
|
-
method: "GET",
|
|
446
|
-
headers,
|
|
447
|
-
path: resolvedPath,
|
|
448
|
-
body,
|
|
449
|
-
});
|
|
276
|
+
b.m("GET").h(headers).b(body);
|
|
277
|
+
return b.build();
|
|
450
278
|
};
|
|
451
279
|
export const se_DescribeDomainsCommand = async (input, context) => {
|
|
452
|
-
const
|
|
280
|
+
const b = rb(input, context);
|
|
453
281
|
const headers = {
|
|
454
282
|
"content-type": "application/json",
|
|
455
283
|
};
|
|
456
|
-
|
|
284
|
+
b.bp("/2021-01-01/opensearch/domain-info");
|
|
457
285
|
let body;
|
|
458
286
|
body = JSON.stringify(take(input, {
|
|
459
287
|
DomainNames: (_) => _json(_),
|
|
460
288
|
}));
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
hostname,
|
|
464
|
-
port,
|
|
465
|
-
method: "POST",
|
|
466
|
-
headers,
|
|
467
|
-
path: resolvedPath,
|
|
468
|
-
body,
|
|
469
|
-
});
|
|
289
|
+
b.m("POST").h(headers).b(body);
|
|
290
|
+
return b.build();
|
|
470
291
|
};
|
|
471
292
|
export const se_DescribeDryRunProgressCommand = async (input, context) => {
|
|
472
|
-
const
|
|
293
|
+
const b = rb(input, context);
|
|
473
294
|
const headers = {};
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
295
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dryRun");
|
|
296
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
477
297
|
const query = map({
|
|
478
|
-
|
|
479
|
-
|
|
298
|
+
[_dRI]: [, input[_DRI]],
|
|
299
|
+
[_lDRC]: [() => input.LoadDryRunConfig !== void 0, () => input[_LDRC].toString()],
|
|
480
300
|
});
|
|
481
301
|
let body;
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
hostname,
|
|
485
|
-
port,
|
|
486
|
-
method: "GET",
|
|
487
|
-
headers,
|
|
488
|
-
path: resolvedPath,
|
|
489
|
-
query,
|
|
490
|
-
body,
|
|
491
|
-
});
|
|
302
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
303
|
+
return b.build();
|
|
492
304
|
};
|
|
493
305
|
export const se_DescribeInboundConnectionsCommand = async (input, context) => {
|
|
494
|
-
const
|
|
306
|
+
const b = rb(input, context);
|
|
495
307
|
const headers = {
|
|
496
308
|
"content-type": "application/json",
|
|
497
309
|
};
|
|
498
|
-
|
|
499
|
-
"/2021-01-01/opensearch/cc/inboundConnection/search";
|
|
310
|
+
b.bp("/2021-01-01/opensearch/cc/inboundConnection/search");
|
|
500
311
|
let body;
|
|
501
312
|
body = JSON.stringify(take(input, {
|
|
502
313
|
Filters: (_) => _json(_),
|
|
503
314
|
MaxResults: [],
|
|
504
315
|
NextToken: [],
|
|
505
316
|
}));
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
hostname,
|
|
509
|
-
port,
|
|
510
|
-
method: "POST",
|
|
511
|
-
headers,
|
|
512
|
-
path: resolvedPath,
|
|
513
|
-
body,
|
|
514
|
-
});
|
|
317
|
+
b.m("POST").h(headers).b(body);
|
|
318
|
+
return b.build();
|
|
515
319
|
};
|
|
516
320
|
export const se_DescribeInstanceTypeLimitsCommand = async (input, context) => {
|
|
517
|
-
const
|
|
321
|
+
const b = rb(input, context);
|
|
518
322
|
const headers = {};
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "EngineVersion", () => input.EngineVersion, "{EngineVersion}", false);
|
|
323
|
+
b.bp("/2021-01-01/opensearch/instanceTypeLimits/{EngineVersion}/{InstanceType}");
|
|
324
|
+
b.p("InstanceType", () => input.InstanceType, "{InstanceType}", false);
|
|
325
|
+
b.p("EngineVersion", () => input.EngineVersion, "{EngineVersion}", false);
|
|
523
326
|
const query = map({
|
|
524
|
-
|
|
327
|
+
[_dN]: [, input[_DN]],
|
|
525
328
|
});
|
|
526
329
|
let body;
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
hostname,
|
|
530
|
-
port,
|
|
531
|
-
method: "GET",
|
|
532
|
-
headers,
|
|
533
|
-
path: resolvedPath,
|
|
534
|
-
query,
|
|
535
|
-
body,
|
|
536
|
-
});
|
|
330
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
331
|
+
return b.build();
|
|
537
332
|
};
|
|
538
333
|
export const se_DescribeOutboundConnectionsCommand = async (input, context) => {
|
|
539
|
-
const
|
|
334
|
+
const b = rb(input, context);
|
|
540
335
|
const headers = {
|
|
541
336
|
"content-type": "application/json",
|
|
542
337
|
};
|
|
543
|
-
|
|
544
|
-
"/2021-01-01/opensearch/cc/outboundConnection/search";
|
|
338
|
+
b.bp("/2021-01-01/opensearch/cc/outboundConnection/search");
|
|
545
339
|
let body;
|
|
546
340
|
body = JSON.stringify(take(input, {
|
|
547
341
|
Filters: (_) => _json(_),
|
|
548
342
|
MaxResults: [],
|
|
549
343
|
NextToken: [],
|
|
550
344
|
}));
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
hostname,
|
|
554
|
-
port,
|
|
555
|
-
method: "POST",
|
|
556
|
-
headers,
|
|
557
|
-
path: resolvedPath,
|
|
558
|
-
body,
|
|
559
|
-
});
|
|
345
|
+
b.m("POST").h(headers).b(body);
|
|
346
|
+
return b.build();
|
|
560
347
|
};
|
|
561
348
|
export const se_DescribePackagesCommand = async (input, context) => {
|
|
562
|
-
const
|
|
349
|
+
const b = rb(input, context);
|
|
563
350
|
const headers = {
|
|
564
351
|
"content-type": "application/json",
|
|
565
352
|
};
|
|
566
|
-
|
|
353
|
+
b.bp("/2021-01-01/packages/describe");
|
|
567
354
|
let body;
|
|
568
355
|
body = JSON.stringify(take(input, {
|
|
569
356
|
Filters: (_) => _json(_),
|
|
570
357
|
MaxResults: [],
|
|
571
358
|
NextToken: [],
|
|
572
359
|
}));
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
hostname,
|
|
576
|
-
port,
|
|
577
|
-
method: "POST",
|
|
578
|
-
headers,
|
|
579
|
-
path: resolvedPath,
|
|
580
|
-
body,
|
|
581
|
-
});
|
|
360
|
+
b.m("POST").h(headers).b(body);
|
|
361
|
+
return b.build();
|
|
582
362
|
};
|
|
583
363
|
export const se_DescribeReservedInstanceOfferingsCommand = async (input, context) => {
|
|
584
|
-
const
|
|
364
|
+
const b = rb(input, context);
|
|
585
365
|
const headers = {};
|
|
586
|
-
|
|
587
|
-
"/2021-01-01/opensearch/reservedInstanceOfferings";
|
|
366
|
+
b.bp("/2021-01-01/opensearch/reservedInstanceOfferings");
|
|
588
367
|
const query = map({
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
368
|
+
[_oI]: [, input[_RIOI]],
|
|
369
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
370
|
+
[_nT]: [, input[_NT]],
|
|
592
371
|
});
|
|
593
372
|
let body;
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
hostname,
|
|
597
|
-
port,
|
|
598
|
-
method: "GET",
|
|
599
|
-
headers,
|
|
600
|
-
path: resolvedPath,
|
|
601
|
-
query,
|
|
602
|
-
body,
|
|
603
|
-
});
|
|
373
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
374
|
+
return b.build();
|
|
604
375
|
};
|
|
605
376
|
export const se_DescribeReservedInstancesCommand = async (input, context) => {
|
|
606
|
-
const
|
|
377
|
+
const b = rb(input, context);
|
|
607
378
|
const headers = {};
|
|
608
|
-
|
|
379
|
+
b.bp("/2021-01-01/opensearch/reservedInstances");
|
|
609
380
|
const query = map({
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
381
|
+
[_rI]: [, input[_RII]],
|
|
382
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
383
|
+
[_nT]: [, input[_NT]],
|
|
613
384
|
});
|
|
614
385
|
let body;
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
hostname,
|
|
618
|
-
port,
|
|
619
|
-
method: "GET",
|
|
620
|
-
headers,
|
|
621
|
-
path: resolvedPath,
|
|
622
|
-
query,
|
|
623
|
-
body,
|
|
624
|
-
});
|
|
386
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
387
|
+
return b.build();
|
|
625
388
|
};
|
|
626
389
|
export const se_DescribeVpcEndpointsCommand = async (input, context) => {
|
|
627
|
-
const
|
|
390
|
+
const b = rb(input, context);
|
|
628
391
|
const headers = {
|
|
629
392
|
"content-type": "application/json",
|
|
630
393
|
};
|
|
631
|
-
|
|
632
|
-
"/2021-01-01/opensearch/vpcEndpoints/describe";
|
|
394
|
+
b.bp("/2021-01-01/opensearch/vpcEndpoints/describe");
|
|
633
395
|
let body;
|
|
634
396
|
body = JSON.stringify(take(input, {
|
|
635
397
|
VpcEndpointIds: (_) => _json(_),
|
|
636
398
|
}));
|
|
637
|
-
|
|
638
|
-
|
|
639
|
-
hostname,
|
|
640
|
-
port,
|
|
641
|
-
method: "POST",
|
|
642
|
-
headers,
|
|
643
|
-
path: resolvedPath,
|
|
644
|
-
body,
|
|
645
|
-
});
|
|
399
|
+
b.m("POST").h(headers).b(body);
|
|
400
|
+
return b.build();
|
|
646
401
|
};
|
|
647
402
|
export const se_DissociatePackageCommand = async (input, context) => {
|
|
648
|
-
const
|
|
403
|
+
const b = rb(input, context);
|
|
649
404
|
const headers = {};
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
405
|
+
b.bp("/2021-01-01/packages/dissociate/{PackageID}/{DomainName}");
|
|
406
|
+
b.p("PackageID", () => input.PackageID, "{PackageID}", false);
|
|
407
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
654
408
|
let body;
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
hostname,
|
|
658
|
-
port,
|
|
659
|
-
method: "POST",
|
|
660
|
-
headers,
|
|
661
|
-
path: resolvedPath,
|
|
662
|
-
body,
|
|
663
|
-
});
|
|
409
|
+
b.m("POST").h(headers).b(body);
|
|
410
|
+
return b.build();
|
|
664
411
|
};
|
|
665
412
|
export const se_GetCompatibleVersionsCommand = async (input, context) => {
|
|
666
|
-
const
|
|
413
|
+
const b = rb(input, context);
|
|
667
414
|
const headers = {};
|
|
668
|
-
|
|
415
|
+
b.bp("/2021-01-01/opensearch/compatibleVersions");
|
|
669
416
|
const query = map({
|
|
670
|
-
|
|
417
|
+
[_dN]: [, input[_DN]],
|
|
671
418
|
});
|
|
672
419
|
let body;
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
hostname,
|
|
676
|
-
port,
|
|
677
|
-
method: "GET",
|
|
678
|
-
headers,
|
|
679
|
-
path: resolvedPath,
|
|
680
|
-
query,
|
|
681
|
-
body,
|
|
682
|
-
});
|
|
420
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
421
|
+
return b.build();
|
|
683
422
|
};
|
|
684
423
|
export const se_GetDataSourceCommand = async (input, context) => {
|
|
685
|
-
const
|
|
424
|
+
const b = rb(input, context);
|
|
686
425
|
const headers = {};
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
|
|
426
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}");
|
|
427
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
428
|
+
b.p("Name", () => input.Name, "{Name}", false);
|
|
691
429
|
let body;
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
hostname,
|
|
695
|
-
port,
|
|
696
|
-
method: "GET",
|
|
697
|
-
headers,
|
|
698
|
-
path: resolvedPath,
|
|
699
|
-
body,
|
|
700
|
-
});
|
|
430
|
+
b.m("GET").h(headers).b(body);
|
|
431
|
+
return b.build();
|
|
701
432
|
};
|
|
702
433
|
export const se_GetDomainMaintenanceStatusCommand = async (input, context) => {
|
|
703
|
-
const
|
|
434
|
+
const b = rb(input, context);
|
|
704
435
|
const headers = {};
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
436
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/domainMaintenance");
|
|
437
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
708
438
|
const query = map({
|
|
709
|
-
|
|
439
|
+
[_mI]: [, __expectNonNull(input[_MI], `MaintenanceId`)],
|
|
710
440
|
});
|
|
711
441
|
let body;
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
hostname,
|
|
715
|
-
port,
|
|
716
|
-
method: "GET",
|
|
717
|
-
headers,
|
|
718
|
-
path: resolvedPath,
|
|
719
|
-
query,
|
|
720
|
-
body,
|
|
721
|
-
});
|
|
442
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
443
|
+
return b.build();
|
|
722
444
|
};
|
|
723
445
|
export const se_GetPackageVersionHistoryCommand = async (input, context) => {
|
|
724
|
-
const
|
|
446
|
+
const b = rb(input, context);
|
|
725
447
|
const headers = {};
|
|
726
|
-
|
|
727
|
-
|
|
448
|
+
b.bp("/2021-01-01/packages/{PackageID}/history");
|
|
449
|
+
b.p("PackageID", () => input.PackageID, "{PackageID}", false);
|
|
728
450
|
const query = map({
|
|
729
|
-
|
|
730
|
-
|
|
451
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
452
|
+
[_nT]: [, input[_NT]],
|
|
731
453
|
});
|
|
732
454
|
let body;
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
hostname,
|
|
736
|
-
port,
|
|
737
|
-
method: "GET",
|
|
738
|
-
headers,
|
|
739
|
-
path: resolvedPath,
|
|
740
|
-
query,
|
|
741
|
-
body,
|
|
742
|
-
});
|
|
455
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
456
|
+
return b.build();
|
|
743
457
|
};
|
|
744
458
|
export const se_GetUpgradeHistoryCommand = async (input, context) => {
|
|
745
|
-
const
|
|
459
|
+
const b = rb(input, context);
|
|
746
460
|
const headers = {};
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
461
|
+
b.bp("/2021-01-01/opensearch/upgradeDomain/{DomainName}/history");
|
|
462
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
750
463
|
const query = map({
|
|
751
|
-
|
|
752
|
-
|
|
464
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
465
|
+
[_nT]: [, input[_NT]],
|
|
753
466
|
});
|
|
754
467
|
let body;
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
hostname,
|
|
758
|
-
port,
|
|
759
|
-
method: "GET",
|
|
760
|
-
headers,
|
|
761
|
-
path: resolvedPath,
|
|
762
|
-
query,
|
|
763
|
-
body,
|
|
764
|
-
});
|
|
468
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
469
|
+
return b.build();
|
|
765
470
|
};
|
|
766
471
|
export const se_GetUpgradeStatusCommand = async (input, context) => {
|
|
767
|
-
const
|
|
472
|
+
const b = rb(input, context);
|
|
768
473
|
const headers = {};
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
474
|
+
b.bp("/2021-01-01/opensearch/upgradeDomain/{DomainName}/status");
|
|
475
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
772
476
|
let body;
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
hostname,
|
|
776
|
-
port,
|
|
777
|
-
method: "GET",
|
|
778
|
-
headers,
|
|
779
|
-
path: resolvedPath,
|
|
780
|
-
body,
|
|
781
|
-
});
|
|
477
|
+
b.m("GET").h(headers).b(body);
|
|
478
|
+
return b.build();
|
|
782
479
|
};
|
|
783
480
|
export const se_ListDataSourcesCommand = async (input, context) => {
|
|
784
|
-
const
|
|
481
|
+
const b = rb(input, context);
|
|
785
482
|
const headers = {};
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
483
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dataSource");
|
|
484
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
789
485
|
let body;
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
hostname,
|
|
793
|
-
port,
|
|
794
|
-
method: "GET",
|
|
795
|
-
headers,
|
|
796
|
-
path: resolvedPath,
|
|
797
|
-
body,
|
|
798
|
-
});
|
|
486
|
+
b.m("GET").h(headers).b(body);
|
|
487
|
+
return b.build();
|
|
799
488
|
};
|
|
800
489
|
export const se_ListDomainMaintenancesCommand = async (input, context) => {
|
|
801
|
-
const
|
|
490
|
+
const b = rb(input, context);
|
|
802
491
|
const headers = {};
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
492
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/domainMaintenances");
|
|
493
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
806
494
|
const query = map({
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
495
|
+
[_a]: [, input[_A]],
|
|
496
|
+
[_s]: [, input[_S]],
|
|
497
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
498
|
+
[_nT]: [, input[_NT]],
|
|
811
499
|
});
|
|
812
500
|
let body;
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
hostname,
|
|
816
|
-
port,
|
|
817
|
-
method: "GET",
|
|
818
|
-
headers,
|
|
819
|
-
path: resolvedPath,
|
|
820
|
-
query,
|
|
821
|
-
body,
|
|
822
|
-
});
|
|
501
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
502
|
+
return b.build();
|
|
823
503
|
};
|
|
824
504
|
export const se_ListDomainNamesCommand = async (input, context) => {
|
|
825
|
-
const
|
|
505
|
+
const b = rb(input, context);
|
|
826
506
|
const headers = {};
|
|
827
|
-
|
|
507
|
+
b.bp("/2021-01-01/domain");
|
|
828
508
|
const query = map({
|
|
829
|
-
|
|
509
|
+
[_eT]: [, input[_ET]],
|
|
830
510
|
});
|
|
831
511
|
let body;
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
hostname,
|
|
835
|
-
port,
|
|
836
|
-
method: "GET",
|
|
837
|
-
headers,
|
|
838
|
-
path: resolvedPath,
|
|
839
|
-
query,
|
|
840
|
-
body,
|
|
841
|
-
});
|
|
512
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
513
|
+
return b.build();
|
|
842
514
|
};
|
|
843
515
|
export const se_ListDomainsForPackageCommand = async (input, context) => {
|
|
844
|
-
const
|
|
516
|
+
const b = rb(input, context);
|
|
845
517
|
const headers = {};
|
|
846
|
-
|
|
847
|
-
|
|
518
|
+
b.bp("/2021-01-01/packages/{PackageID}/domains");
|
|
519
|
+
b.p("PackageID", () => input.PackageID, "{PackageID}", false);
|
|
848
520
|
const query = map({
|
|
849
|
-
|
|
850
|
-
|
|
521
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
522
|
+
[_nT]: [, input[_NT]],
|
|
851
523
|
});
|
|
852
524
|
let body;
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
hostname,
|
|
856
|
-
port,
|
|
857
|
-
method: "GET",
|
|
858
|
-
headers,
|
|
859
|
-
path: resolvedPath,
|
|
860
|
-
query,
|
|
861
|
-
body,
|
|
862
|
-
});
|
|
525
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
526
|
+
return b.build();
|
|
863
527
|
};
|
|
864
528
|
export const se_ListInstanceTypeDetailsCommand = async (input, context) => {
|
|
865
|
-
const
|
|
529
|
+
const b = rb(input, context);
|
|
866
530
|
const headers = {};
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "EngineVersion", () => input.EngineVersion, "{EngineVersion}", false);
|
|
531
|
+
b.bp("/2021-01-01/opensearch/instanceTypeDetails/{EngineVersion}");
|
|
532
|
+
b.p("EngineVersion", () => input.EngineVersion, "{EngineVersion}", false);
|
|
870
533
|
const query = map({
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
534
|
+
[_dN]: [, input[_DN]],
|
|
535
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
536
|
+
[_nT]: [, input[_NT]],
|
|
537
|
+
[_rAZ]: [() => input.RetrieveAZs !== void 0, () => input[_RAZ].toString()],
|
|
538
|
+
[_iT]: [, input[_IT]],
|
|
876
539
|
});
|
|
877
540
|
let body;
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
hostname,
|
|
881
|
-
port,
|
|
882
|
-
method: "GET",
|
|
883
|
-
headers,
|
|
884
|
-
path: resolvedPath,
|
|
885
|
-
query,
|
|
886
|
-
body,
|
|
887
|
-
});
|
|
541
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
542
|
+
return b.build();
|
|
888
543
|
};
|
|
889
544
|
export const se_ListPackagesForDomainCommand = async (input, context) => {
|
|
890
|
-
const
|
|
545
|
+
const b = rb(input, context);
|
|
891
546
|
const headers = {};
|
|
892
|
-
|
|
893
|
-
|
|
547
|
+
b.bp("/2021-01-01/domain/{DomainName}/packages");
|
|
548
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
894
549
|
const query = map({
|
|
895
|
-
|
|
896
|
-
|
|
550
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
551
|
+
[_nT]: [, input[_NT]],
|
|
897
552
|
});
|
|
898
553
|
let body;
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
hostname,
|
|
902
|
-
port,
|
|
903
|
-
method: "GET",
|
|
904
|
-
headers,
|
|
905
|
-
path: resolvedPath,
|
|
906
|
-
query,
|
|
907
|
-
body,
|
|
908
|
-
});
|
|
554
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
555
|
+
return b.build();
|
|
909
556
|
};
|
|
910
557
|
export const se_ListScheduledActionsCommand = async (input, context) => {
|
|
911
|
-
const
|
|
558
|
+
const b = rb(input, context);
|
|
912
559
|
const headers = {};
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
560
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/scheduledActions");
|
|
561
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
916
562
|
const query = map({
|
|
917
|
-
|
|
918
|
-
|
|
563
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
564
|
+
[_nT]: [, input[_NT]],
|
|
919
565
|
});
|
|
920
566
|
let body;
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
hostname,
|
|
924
|
-
port,
|
|
925
|
-
method: "GET",
|
|
926
|
-
headers,
|
|
927
|
-
path: resolvedPath,
|
|
928
|
-
query,
|
|
929
|
-
body,
|
|
930
|
-
});
|
|
567
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
568
|
+
return b.build();
|
|
931
569
|
};
|
|
932
570
|
export const se_ListTagsCommand = async (input, context) => {
|
|
933
|
-
const
|
|
571
|
+
const b = rb(input, context);
|
|
934
572
|
const headers = {};
|
|
935
|
-
|
|
573
|
+
b.bp("/2021-01-01/tags");
|
|
936
574
|
const query = map({
|
|
937
|
-
|
|
575
|
+
[_ar]: [, __expectNonNull(input[_ARN], `ARN`)],
|
|
938
576
|
});
|
|
939
577
|
let body;
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
hostname,
|
|
943
|
-
port,
|
|
944
|
-
method: "GET",
|
|
945
|
-
headers,
|
|
946
|
-
path: resolvedPath,
|
|
947
|
-
query,
|
|
948
|
-
body,
|
|
949
|
-
});
|
|
578
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
579
|
+
return b.build();
|
|
950
580
|
};
|
|
951
581
|
export const se_ListVersionsCommand = async (input, context) => {
|
|
952
|
-
const
|
|
582
|
+
const b = rb(input, context);
|
|
953
583
|
const headers = {};
|
|
954
|
-
|
|
584
|
+
b.bp("/2021-01-01/opensearch/versions");
|
|
955
585
|
const query = map({
|
|
956
|
-
|
|
957
|
-
|
|
586
|
+
[_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
587
|
+
[_nT]: [, input[_NT]],
|
|
958
588
|
});
|
|
959
589
|
let body;
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
hostname,
|
|
963
|
-
port,
|
|
964
|
-
method: "GET",
|
|
965
|
-
headers,
|
|
966
|
-
path: resolvedPath,
|
|
967
|
-
query,
|
|
968
|
-
body,
|
|
969
|
-
});
|
|
590
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
591
|
+
return b.build();
|
|
970
592
|
};
|
|
971
593
|
export const se_ListVpcEndpointAccessCommand = async (input, context) => {
|
|
972
|
-
const
|
|
594
|
+
const b = rb(input, context);
|
|
973
595
|
const headers = {};
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
596
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/listVpcEndpointAccess");
|
|
597
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
977
598
|
const query = map({
|
|
978
|
-
|
|
599
|
+
[_nT]: [, input[_NT]],
|
|
979
600
|
});
|
|
980
601
|
let body;
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
hostname,
|
|
984
|
-
port,
|
|
985
|
-
method: "GET",
|
|
986
|
-
headers,
|
|
987
|
-
path: resolvedPath,
|
|
988
|
-
query,
|
|
989
|
-
body,
|
|
990
|
-
});
|
|
602
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
603
|
+
return b.build();
|
|
991
604
|
};
|
|
992
605
|
export const se_ListVpcEndpointsCommand = async (input, context) => {
|
|
993
|
-
const
|
|
606
|
+
const b = rb(input, context);
|
|
994
607
|
const headers = {};
|
|
995
|
-
|
|
608
|
+
b.bp("/2021-01-01/opensearch/vpcEndpoints");
|
|
996
609
|
const query = map({
|
|
997
|
-
|
|
610
|
+
[_nT]: [, input[_NT]],
|
|
998
611
|
});
|
|
999
612
|
let body;
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
hostname,
|
|
1003
|
-
port,
|
|
1004
|
-
method: "GET",
|
|
1005
|
-
headers,
|
|
1006
|
-
path: resolvedPath,
|
|
1007
|
-
query,
|
|
1008
|
-
body,
|
|
1009
|
-
});
|
|
613
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
614
|
+
return b.build();
|
|
1010
615
|
};
|
|
1011
616
|
export const se_ListVpcEndpointsForDomainCommand = async (input, context) => {
|
|
1012
|
-
const
|
|
617
|
+
const b = rb(input, context);
|
|
1013
618
|
const headers = {};
|
|
1014
|
-
|
|
1015
|
-
|
|
1016
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
619
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/vpcEndpoints");
|
|
620
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1017
621
|
const query = map({
|
|
1018
|
-
|
|
622
|
+
[_nT]: [, input[_NT]],
|
|
1019
623
|
});
|
|
1020
624
|
let body;
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
hostname,
|
|
1024
|
-
port,
|
|
1025
|
-
method: "GET",
|
|
1026
|
-
headers,
|
|
1027
|
-
path: resolvedPath,
|
|
1028
|
-
query,
|
|
1029
|
-
body,
|
|
1030
|
-
});
|
|
625
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
626
|
+
return b.build();
|
|
1031
627
|
};
|
|
1032
628
|
export const se_PurchaseReservedInstanceOfferingCommand = async (input, context) => {
|
|
1033
|
-
const
|
|
629
|
+
const b = rb(input, context);
|
|
1034
630
|
const headers = {
|
|
1035
631
|
"content-type": "application/json",
|
|
1036
632
|
};
|
|
1037
|
-
|
|
1038
|
-
"/2021-01-01/opensearch/purchaseReservedInstanceOffering";
|
|
633
|
+
b.bp("/2021-01-01/opensearch/purchaseReservedInstanceOffering");
|
|
1039
634
|
let body;
|
|
1040
635
|
body = JSON.stringify(take(input, {
|
|
1041
636
|
InstanceCount: [],
|
|
1042
637
|
ReservationName: [],
|
|
1043
638
|
ReservedInstanceOfferingId: [],
|
|
1044
639
|
}));
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
hostname,
|
|
1048
|
-
port,
|
|
1049
|
-
method: "POST",
|
|
1050
|
-
headers,
|
|
1051
|
-
path: resolvedPath,
|
|
1052
|
-
body,
|
|
1053
|
-
});
|
|
640
|
+
b.m("POST").h(headers).b(body);
|
|
641
|
+
return b.build();
|
|
1054
642
|
};
|
|
1055
643
|
export const se_RejectInboundConnectionCommand = async (input, context) => {
|
|
1056
|
-
const
|
|
644
|
+
const b = rb(input, context);
|
|
1057
645
|
const headers = {};
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
646
|
+
b.bp("/2021-01-01/opensearch/cc/inboundConnection/{ConnectionId}/reject");
|
|
647
|
+
b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
|
|
1061
648
|
let body;
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
hostname,
|
|
1065
|
-
port,
|
|
1066
|
-
method: "PUT",
|
|
1067
|
-
headers,
|
|
1068
|
-
path: resolvedPath,
|
|
1069
|
-
body,
|
|
1070
|
-
});
|
|
649
|
+
b.m("PUT").h(headers).b(body);
|
|
650
|
+
return b.build();
|
|
1071
651
|
};
|
|
1072
652
|
export const se_RemoveTagsCommand = async (input, context) => {
|
|
1073
|
-
const
|
|
653
|
+
const b = rb(input, context);
|
|
1074
654
|
const headers = {
|
|
1075
655
|
"content-type": "application/json",
|
|
1076
656
|
};
|
|
1077
|
-
|
|
657
|
+
b.bp("/2021-01-01/tags-removal");
|
|
1078
658
|
let body;
|
|
1079
659
|
body = JSON.stringify(take(input, {
|
|
1080
660
|
ARN: [],
|
|
1081
661
|
TagKeys: (_) => _json(_),
|
|
1082
662
|
}));
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
hostname,
|
|
1086
|
-
port,
|
|
1087
|
-
method: "POST",
|
|
1088
|
-
headers,
|
|
1089
|
-
path: resolvedPath,
|
|
1090
|
-
body,
|
|
1091
|
-
});
|
|
663
|
+
b.m("POST").h(headers).b(body);
|
|
664
|
+
return b.build();
|
|
1092
665
|
};
|
|
1093
666
|
export const se_RevokeVpcEndpointAccessCommand = async (input, context) => {
|
|
1094
|
-
const
|
|
667
|
+
const b = rb(input, context);
|
|
1095
668
|
const headers = {
|
|
1096
669
|
"content-type": "application/json",
|
|
1097
670
|
};
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
671
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/revokeVpcEndpointAccess");
|
|
672
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1101
673
|
let body;
|
|
1102
674
|
body = JSON.stringify(take(input, {
|
|
1103
675
|
Account: [],
|
|
1104
676
|
}));
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
hostname,
|
|
1108
|
-
port,
|
|
1109
|
-
method: "POST",
|
|
1110
|
-
headers,
|
|
1111
|
-
path: resolvedPath,
|
|
1112
|
-
body,
|
|
1113
|
-
});
|
|
677
|
+
b.m("POST").h(headers).b(body);
|
|
678
|
+
return b.build();
|
|
1114
679
|
};
|
|
1115
680
|
export const se_StartDomainMaintenanceCommand = async (input, context) => {
|
|
1116
|
-
const
|
|
681
|
+
const b = rb(input, context);
|
|
1117
682
|
const headers = {
|
|
1118
683
|
"content-type": "application/json",
|
|
1119
684
|
};
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
685
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/domainMaintenance");
|
|
686
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1123
687
|
let body;
|
|
1124
688
|
body = JSON.stringify(take(input, {
|
|
1125
689
|
Action: [],
|
|
1126
690
|
NodeId: [],
|
|
1127
691
|
}));
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
hostname,
|
|
1131
|
-
port,
|
|
1132
|
-
method: "POST",
|
|
1133
|
-
headers,
|
|
1134
|
-
path: resolvedPath,
|
|
1135
|
-
body,
|
|
1136
|
-
});
|
|
692
|
+
b.m("POST").h(headers).b(body);
|
|
693
|
+
return b.build();
|
|
1137
694
|
};
|
|
1138
695
|
export const se_StartServiceSoftwareUpdateCommand = async (input, context) => {
|
|
1139
|
-
const
|
|
696
|
+
const b = rb(input, context);
|
|
1140
697
|
const headers = {
|
|
1141
698
|
"content-type": "application/json",
|
|
1142
699
|
};
|
|
1143
|
-
|
|
1144
|
-
"/2021-01-01/opensearch/serviceSoftwareUpdate/start";
|
|
700
|
+
b.bp("/2021-01-01/opensearch/serviceSoftwareUpdate/start");
|
|
1145
701
|
let body;
|
|
1146
702
|
body = JSON.stringify(take(input, {
|
|
1147
703
|
DesiredStartTime: [],
|
|
1148
704
|
DomainName: [],
|
|
1149
705
|
ScheduleAt: [],
|
|
1150
706
|
}));
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
hostname,
|
|
1154
|
-
port,
|
|
1155
|
-
method: "POST",
|
|
1156
|
-
headers,
|
|
1157
|
-
path: resolvedPath,
|
|
1158
|
-
body,
|
|
1159
|
-
});
|
|
707
|
+
b.m("POST").h(headers).b(body);
|
|
708
|
+
return b.build();
|
|
1160
709
|
};
|
|
1161
710
|
export const se_UpdateDataSourceCommand = async (input, context) => {
|
|
1162
|
-
const
|
|
711
|
+
const b = rb(input, context);
|
|
1163
712
|
const headers = {
|
|
1164
713
|
"content-type": "application/json",
|
|
1165
714
|
};
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
|
|
715
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}");
|
|
716
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
717
|
+
b.p("Name", () => input.Name, "{Name}", false);
|
|
1170
718
|
let body;
|
|
1171
719
|
body = JSON.stringify(take(input, {
|
|
1172
720
|
DataSourceType: (_) => _json(_),
|
|
1173
721
|
Description: [],
|
|
1174
722
|
}));
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
hostname,
|
|
1178
|
-
port,
|
|
1179
|
-
method: "PUT",
|
|
1180
|
-
headers,
|
|
1181
|
-
path: resolvedPath,
|
|
1182
|
-
body,
|
|
1183
|
-
});
|
|
723
|
+
b.m("PUT").h(headers).b(body);
|
|
724
|
+
return b.build();
|
|
1184
725
|
};
|
|
1185
726
|
export const se_UpdateDomainConfigCommand = async (input, context) => {
|
|
1186
|
-
const
|
|
727
|
+
const b = rb(input, context);
|
|
1187
728
|
const headers = {
|
|
1188
729
|
"content-type": "application/json",
|
|
1189
730
|
};
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
731
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/config");
|
|
732
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1193
733
|
let body;
|
|
1194
734
|
body = JSON.stringify(take(input, {
|
|
1195
735
|
AccessPolicies: [],
|
|
@@ -1211,22 +751,15 @@ export const se_UpdateDomainConfigCommand = async (input, context) => {
|
|
|
1211
751
|
SoftwareUpdateOptions: (_) => _json(_),
|
|
1212
752
|
VPCOptions: (_) => _json(_),
|
|
1213
753
|
}));
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
hostname,
|
|
1217
|
-
port,
|
|
1218
|
-
method: "POST",
|
|
1219
|
-
headers,
|
|
1220
|
-
path: resolvedPath,
|
|
1221
|
-
body,
|
|
1222
|
-
});
|
|
754
|
+
b.m("POST").h(headers).b(body);
|
|
755
|
+
return b.build();
|
|
1223
756
|
};
|
|
1224
757
|
export const se_UpdatePackageCommand = async (input, context) => {
|
|
1225
|
-
const
|
|
758
|
+
const b = rb(input, context);
|
|
1226
759
|
const headers = {
|
|
1227
760
|
"content-type": "application/json",
|
|
1228
761
|
};
|
|
1229
|
-
|
|
762
|
+
b.bp("/2021-01-01/packages/update");
|
|
1230
763
|
let body;
|
|
1231
764
|
body = JSON.stringify(take(input, {
|
|
1232
765
|
CommitMessage: [],
|
|
@@ -1234,24 +767,16 @@ export const se_UpdatePackageCommand = async (input, context) => {
|
|
|
1234
767
|
PackageID: [],
|
|
1235
768
|
PackageSource: (_) => _json(_),
|
|
1236
769
|
}));
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
hostname,
|
|
1240
|
-
port,
|
|
1241
|
-
method: "POST",
|
|
1242
|
-
headers,
|
|
1243
|
-
path: resolvedPath,
|
|
1244
|
-
body,
|
|
1245
|
-
});
|
|
770
|
+
b.m("POST").h(headers).b(body);
|
|
771
|
+
return b.build();
|
|
1246
772
|
};
|
|
1247
773
|
export const se_UpdateScheduledActionCommand = async (input, context) => {
|
|
1248
|
-
const
|
|
774
|
+
const b = rb(input, context);
|
|
1249
775
|
const headers = {
|
|
1250
776
|
"content-type": "application/json",
|
|
1251
777
|
};
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
778
|
+
b.bp("/2021-01-01/opensearch/domain/{DomainName}/scheduledAction/update");
|
|
779
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1255
780
|
let body;
|
|
1256
781
|
body = JSON.stringify(take(input, {
|
|
1257
782
|
ActionID: [],
|
|
@@ -1259,44 +784,29 @@ export const se_UpdateScheduledActionCommand = async (input, context) => {
|
|
|
1259
784
|
DesiredStartTime: [],
|
|
1260
785
|
ScheduleAt: [],
|
|
1261
786
|
}));
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
hostname,
|
|
1265
|
-
port,
|
|
1266
|
-
method: "PUT",
|
|
1267
|
-
headers,
|
|
1268
|
-
path: resolvedPath,
|
|
1269
|
-
body,
|
|
1270
|
-
});
|
|
787
|
+
b.m("PUT").h(headers).b(body);
|
|
788
|
+
return b.build();
|
|
1271
789
|
};
|
|
1272
790
|
export const se_UpdateVpcEndpointCommand = async (input, context) => {
|
|
1273
|
-
const
|
|
791
|
+
const b = rb(input, context);
|
|
1274
792
|
const headers = {
|
|
1275
793
|
"content-type": "application/json",
|
|
1276
794
|
};
|
|
1277
|
-
|
|
1278
|
-
"/2021-01-01/opensearch/vpcEndpoints/update";
|
|
795
|
+
b.bp("/2021-01-01/opensearch/vpcEndpoints/update");
|
|
1279
796
|
let body;
|
|
1280
797
|
body = JSON.stringify(take(input, {
|
|
1281
798
|
VpcEndpointId: [],
|
|
1282
799
|
VpcOptions: (_) => _json(_),
|
|
1283
800
|
}));
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
hostname,
|
|
1287
|
-
port,
|
|
1288
|
-
method: "POST",
|
|
1289
|
-
headers,
|
|
1290
|
-
path: resolvedPath,
|
|
1291
|
-
body,
|
|
1292
|
-
});
|
|
801
|
+
b.m("POST").h(headers).b(body);
|
|
802
|
+
return b.build();
|
|
1293
803
|
};
|
|
1294
804
|
export const se_UpgradeDomainCommand = async (input, context) => {
|
|
1295
|
-
const
|
|
805
|
+
const b = rb(input, context);
|
|
1296
806
|
const headers = {
|
|
1297
807
|
"content-type": "application/json",
|
|
1298
808
|
};
|
|
1299
|
-
|
|
809
|
+
b.bp("/2021-01-01/opensearch/upgradeDomain");
|
|
1300
810
|
let body;
|
|
1301
811
|
body = JSON.stringify(take(input, {
|
|
1302
812
|
AdvancedOptions: (_) => _json(_),
|
|
@@ -1304,15 +814,8 @@ export const se_UpgradeDomainCommand = async (input, context) => {
|
|
|
1304
814
|
PerformCheckOnly: [],
|
|
1305
815
|
TargetVersion: [],
|
|
1306
816
|
}));
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
hostname,
|
|
1310
|
-
port,
|
|
1311
|
-
method: "POST",
|
|
1312
|
-
headers,
|
|
1313
|
-
path: resolvedPath,
|
|
1314
|
-
body,
|
|
1315
|
-
});
|
|
817
|
+
b.m("POST").h(headers).b(body);
|
|
818
|
+
return b.build();
|
|
1316
819
|
};
|
|
1317
820
|
export const de_AcceptInboundConnectionCommand = async (output, context) => {
|
|
1318
821
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4754,6 +4257,36 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
4754
4257
|
value !== "" &&
|
|
4755
4258
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
4756
4259
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
4260
|
+
const _A = "Action";
|
|
4261
|
+
const _ARN = "ARN";
|
|
4262
|
+
const _CI = "ChangeId";
|
|
4263
|
+
const _DN = "DomainName";
|
|
4264
|
+
const _DRI = "DryRunId";
|
|
4265
|
+
const _ET = "EngineType";
|
|
4266
|
+
const _IT = "InstanceType";
|
|
4267
|
+
const _LDRC = "LoadDryRunConfig";
|
|
4268
|
+
const _MI = "MaintenanceId";
|
|
4269
|
+
const _MR = "MaxResults";
|
|
4270
|
+
const _NT = "NextToken";
|
|
4271
|
+
const _RAZ = "RetrieveAZs";
|
|
4272
|
+
const _RII = "ReservedInstanceId";
|
|
4273
|
+
const _RIOI = "ReservedInstanceOfferingId";
|
|
4274
|
+
const _S = "Status";
|
|
4275
|
+
const _a = "action";
|
|
4276
|
+
const _ar = "arn";
|
|
4277
|
+
const _c = "changeid";
|
|
4278
|
+
const _dN = "domainName";
|
|
4279
|
+
const _dRI = "dryRunId";
|
|
4280
|
+
const _eT = "engineType";
|
|
4281
|
+
const _iT = "instanceType";
|
|
4282
|
+
const _lDRC = "loadDryRunConfig";
|
|
4283
|
+
const _mI = "maintenanceId";
|
|
4284
|
+
const _mR = "maxResults";
|
|
4285
|
+
const _nT = "nextToken";
|
|
4286
|
+
const _oI = "offeringId";
|
|
4287
|
+
const _rAZ = "retrieveAZs";
|
|
4288
|
+
const _rI = "reservationId";
|
|
4289
|
+
const _s = "status";
|
|
4757
4290
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
4758
4291
|
if (encoded.length) {
|
|
4759
4292
|
return JSON.parse(encoded);
|