@aws-sdk/client-elasticsearch-service 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.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +272 -644
  2. package/dist-es/protocols/Aws_restJson1.js +273 -645
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,112 +1,73 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, 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";
3
3
  import { ElasticsearchServiceServiceException as __BaseException } from "../models/ElasticsearchServiceServiceException";
4
4
  import { AccessDeniedException, BaseException, ConflictException, DisabledOperationException, InternalException, InvalidPaginationTokenException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ValidationException, } from "../models/models_0";
5
5
  export const se_AcceptInboundCrossClusterSearchConnectionCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {};
8
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
9
- "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/accept";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
8
+ b.bp("/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/accept");
9
+ b.p("CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
11
10
  let body;
12
- return new __HttpRequest({
13
- protocol,
14
- hostname,
15
- port,
16
- method: "PUT",
17
- headers,
18
- path: resolvedPath,
19
- body,
20
- });
11
+ b.m("PUT").h(headers).b(body);
12
+ return b.build();
21
13
  };
22
14
  export const se_AddTagsCommand = async (input, context) => {
23
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
15
+ const b = rb(input, context);
24
16
  const headers = {
25
17
  "content-type": "application/json",
26
18
  };
27
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags";
19
+ b.bp("/2015-01-01/tags");
28
20
  let body;
29
21
  body = JSON.stringify(take(input, {
30
22
  ARN: [],
31
23
  TagList: (_) => _json(_),
32
24
  }));
33
- return new __HttpRequest({
34
- protocol,
35
- hostname,
36
- port,
37
- method: "POST",
38
- headers,
39
- path: resolvedPath,
40
- body,
41
- });
25
+ b.m("POST").h(headers).b(body);
26
+ return b.build();
42
27
  };
43
28
  export const se_AssociatePackageCommand = async (input, context) => {
44
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
29
+ const b = rb(input, context);
45
30
  const headers = {};
46
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
47
- "/2015-01-01/packages/associate/{PackageID}/{DomainName}";
48
- resolvedPath = __resolvedPath(resolvedPath, input, "PackageID", () => input.PackageID, "{PackageID}", false);
49
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
31
+ b.bp("/2015-01-01/packages/associate/{PackageID}/{DomainName}");
32
+ b.p("PackageID", () => input.PackageID, "{PackageID}", false);
33
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
50
34
  let body;
51
- return new __HttpRequest({
52
- protocol,
53
- hostname,
54
- port,
55
- method: "POST",
56
- headers,
57
- path: resolvedPath,
58
- body,
59
- });
35
+ b.m("POST").h(headers).b(body);
36
+ return b.build();
60
37
  };
61
38
  export const se_AuthorizeVpcEndpointAccessCommand = async (input, context) => {
62
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
39
+ const b = rb(input, context);
63
40
  const headers = {
64
41
  "content-type": "application/json",
65
42
  };
66
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
67
- "/2015-01-01/es/domain/{DomainName}/authorizeVpcEndpointAccess";
68
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
43
+ b.bp("/2015-01-01/es/domain/{DomainName}/authorizeVpcEndpointAccess");
44
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
69
45
  let body;
70
46
  body = JSON.stringify(take(input, {
71
47
  Account: [],
72
48
  }));
73
- return new __HttpRequest({
74
- protocol,
75
- hostname,
76
- port,
77
- method: "POST",
78
- headers,
79
- path: resolvedPath,
80
- body,
81
- });
49
+ b.m("POST").h(headers).b(body);
50
+ return b.build();
82
51
  };
83
52
  export const se_CancelElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
84
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
53
+ const b = rb(input, context);
85
54
  const headers = {
86
55
  "content-type": "application/json",
87
56
  };
88
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
89
- "/2015-01-01/es/serviceSoftwareUpdate/cancel";
57
+ b.bp("/2015-01-01/es/serviceSoftwareUpdate/cancel");
90
58
  let body;
91
59
  body = JSON.stringify(take(input, {
92
60
  DomainName: [],
93
61
  }));
94
- return new __HttpRequest({
95
- protocol,
96
- hostname,
97
- port,
98
- method: "POST",
99
- headers,
100
- path: resolvedPath,
101
- body,
102
- });
62
+ b.m("POST").h(headers).b(body);
63
+ return b.build();
103
64
  };
104
65
  export const se_CreateElasticsearchDomainCommand = async (input, context) => {
105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = rb(input, context);
106
67
  const headers = {
107
68
  "content-type": "application/json",
108
69
  };
109
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain";
70
+ b.bp("/2015-01-01/es/domain");
110
71
  let body;
111
72
  body = JSON.stringify(take(input, {
112
73
  AccessPolicies: [],
@@ -126,44 +87,30 @@ export const se_CreateElasticsearchDomainCommand = async (input, context) => {
126
87
  TagList: (_) => _json(_),
127
88
  VPCOptions: (_) => _json(_),
128
89
  }));
129
- return new __HttpRequest({
130
- protocol,
131
- hostname,
132
- port,
133
- method: "POST",
134
- headers,
135
- path: resolvedPath,
136
- body,
137
- });
90
+ b.m("POST").h(headers).b(body);
91
+ return b.build();
138
92
  };
139
93
  export const se_CreateOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
140
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
94
+ const b = rb(input, context);
141
95
  const headers = {
142
96
  "content-type": "application/json",
143
97
  };
144
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/ccs/outboundConnection";
98
+ b.bp("/2015-01-01/es/ccs/outboundConnection");
145
99
  let body;
146
100
  body = JSON.stringify(take(input, {
147
101
  ConnectionAlias: [],
148
102
  DestinationDomainInfo: (_) => _json(_),
149
103
  SourceDomainInfo: (_) => _json(_),
150
104
  }));
151
- return new __HttpRequest({
152
- protocol,
153
- hostname,
154
- port,
155
- method: "POST",
156
- headers,
157
- path: resolvedPath,
158
- body,
159
- });
105
+ b.m("POST").h(headers).b(body);
106
+ return b.build();
160
107
  };
161
108
  export const se_CreatePackageCommand = async (input, context) => {
162
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
109
+ const b = rb(input, context);
163
110
  const headers = {
164
111
  "content-type": "application/json",
165
112
  };
166
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages";
113
+ b.bp("/2015-01-01/packages");
167
114
  let body;
168
115
  body = JSON.stringify(take(input, {
169
116
  PackageDescription: [],
@@ -171,779 +118,472 @@ export const se_CreatePackageCommand = async (input, context) => {
171
118
  PackageSource: (_) => _json(_),
172
119
  PackageType: [],
173
120
  }));
174
- return new __HttpRequest({
175
- protocol,
176
- hostname,
177
- port,
178
- method: "POST",
179
- headers,
180
- path: resolvedPath,
181
- body,
182
- });
121
+ b.m("POST").h(headers).b(body);
122
+ return b.build();
183
123
  };
184
124
  export const se_CreateVpcEndpointCommand = async (input, context) => {
185
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
125
+ const b = rb(input, context);
186
126
  const headers = {
187
127
  "content-type": "application/json",
188
128
  };
189
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints";
129
+ b.bp("/2015-01-01/es/vpcEndpoints");
190
130
  let body;
191
131
  body = JSON.stringify(take(input, {
192
132
  ClientToken: [],
193
133
  DomainArn: [],
194
134
  VpcOptions: (_) => _json(_),
195
135
  }));
196
- return new __HttpRequest({
197
- protocol,
198
- hostname,
199
- port,
200
- method: "POST",
201
- headers,
202
- path: resolvedPath,
203
- body,
204
- });
136
+ b.m("POST").h(headers).b(body);
137
+ return b.build();
205
138
  };
206
139
  export const se_DeleteElasticsearchDomainCommand = async (input, context) => {
207
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
140
+ const b = rb(input, context);
208
141
  const headers = {};
209
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}";
210
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
142
+ b.bp("/2015-01-01/es/domain/{DomainName}");
143
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
211
144
  let body;
212
- return new __HttpRequest({
213
- protocol,
214
- hostname,
215
- port,
216
- method: "DELETE",
217
- headers,
218
- path: resolvedPath,
219
- body,
220
- });
145
+ b.m("DELETE").h(headers).b(body);
146
+ return b.build();
221
147
  };
222
148
  export const se_DeleteElasticsearchServiceRoleCommand = async (input, context) => {
223
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
149
+ const b = rb(input, context);
224
150
  const headers = {
225
151
  "content-type": "application/json",
226
152
  };
227
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/role";
153
+ b.bp("/2015-01-01/es/role");
228
154
  let body;
229
155
  body = "";
230
- return new __HttpRequest({
231
- protocol,
232
- hostname,
233
- port,
234
- method: "DELETE",
235
- headers,
236
- path: resolvedPath,
237
- body,
238
- });
156
+ b.m("DELETE").h(headers).b(body);
157
+ return b.build();
239
158
  };
240
159
  export const se_DeleteInboundCrossClusterSearchConnectionCommand = async (input, context) => {
241
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
160
+ const b = rb(input, context);
242
161
  const headers = {};
243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
244
- "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}";
245
- resolvedPath = __resolvedPath(resolvedPath, input, "CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
162
+ b.bp("/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}");
163
+ b.p("CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
246
164
  let body;
247
- return new __HttpRequest({
248
- protocol,
249
- hostname,
250
- port,
251
- method: "DELETE",
252
- headers,
253
- path: resolvedPath,
254
- body,
255
- });
165
+ b.m("DELETE").h(headers).b(body);
166
+ return b.build();
256
167
  };
257
168
  export const se_DeleteOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
258
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
169
+ const b = rb(input, context);
259
170
  const headers = {};
260
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
261
- "/2015-01-01/es/ccs/outboundConnection/{CrossClusterSearchConnectionId}";
262
- resolvedPath = __resolvedPath(resolvedPath, input, "CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
171
+ b.bp("/2015-01-01/es/ccs/outboundConnection/{CrossClusterSearchConnectionId}");
172
+ b.p("CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
263
173
  let body;
264
- return new __HttpRequest({
265
- protocol,
266
- hostname,
267
- port,
268
- method: "DELETE",
269
- headers,
270
- path: resolvedPath,
271
- body,
272
- });
174
+ b.m("DELETE").h(headers).b(body);
175
+ return b.build();
273
176
  };
274
177
  export const se_DeletePackageCommand = async (input, context) => {
275
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
178
+ const b = rb(input, context);
276
179
  const headers = {};
277
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}";
278
- resolvedPath = __resolvedPath(resolvedPath, input, "PackageID", () => input.PackageID, "{PackageID}", false);
180
+ b.bp("/2015-01-01/packages/{PackageID}");
181
+ b.p("PackageID", () => input.PackageID, "{PackageID}", false);
279
182
  let body;
280
- return new __HttpRequest({
281
- protocol,
282
- hostname,
283
- port,
284
- method: "DELETE",
285
- headers,
286
- path: resolvedPath,
287
- body,
288
- });
183
+ b.m("DELETE").h(headers).b(body);
184
+ return b.build();
289
185
  };
290
186
  export const se_DeleteVpcEndpointCommand = async (input, context) => {
291
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
187
+ const b = rb(input, context);
292
188
  const headers = {};
293
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
294
- "/2015-01-01/es/vpcEndpoints/{VpcEndpointId}";
295
- resolvedPath = __resolvedPath(resolvedPath, input, "VpcEndpointId", () => input.VpcEndpointId, "{VpcEndpointId}", false);
189
+ b.bp("/2015-01-01/es/vpcEndpoints/{VpcEndpointId}");
190
+ b.p("VpcEndpointId", () => input.VpcEndpointId, "{VpcEndpointId}", false);
296
191
  let body;
297
- return new __HttpRequest({
298
- protocol,
299
- hostname,
300
- port,
301
- method: "DELETE",
302
- headers,
303
- path: resolvedPath,
304
- body,
305
- });
192
+ b.m("DELETE").h(headers).b(body);
193
+ return b.build();
306
194
  };
307
195
  export const se_DescribeDomainAutoTunesCommand = async (input, context) => {
308
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
196
+ const b = rb(input, context);
309
197
  const headers = {
310
198
  "content-type": "application/json",
311
199
  };
312
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
313
- "/2015-01-01/es/domain/{DomainName}/autoTunes";
314
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
200
+ b.bp("/2015-01-01/es/domain/{DomainName}/autoTunes");
201
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
315
202
  let body;
316
203
  body = JSON.stringify(take(input, {
317
204
  MaxResults: [],
318
205
  NextToken: [],
319
206
  }));
320
- return new __HttpRequest({
321
- protocol,
322
- hostname,
323
- port,
324
- method: "GET",
325
- headers,
326
- path: resolvedPath,
327
- body,
328
- });
207
+ b.m("GET").h(headers).b(body);
208
+ return b.build();
329
209
  };
330
210
  export const se_DescribeDomainChangeProgressCommand = async (input, context) => {
331
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
211
+ const b = rb(input, context);
332
212
  const headers = {};
333
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
334
- "/2015-01-01/es/domain/{DomainName}/progress";
335
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
213
+ b.bp("/2015-01-01/es/domain/{DomainName}/progress");
214
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
336
215
  const query = map({
337
- changeid: [, input.ChangeId],
216
+ [_c]: [, input[_CI]],
338
217
  });
339
218
  let body;
340
- return new __HttpRequest({
341
- protocol,
342
- hostname,
343
- port,
344
- method: "GET",
345
- headers,
346
- path: resolvedPath,
347
- query,
348
- body,
349
- });
219
+ b.m("GET").h(headers).q(query).b(body);
220
+ return b.build();
350
221
  };
351
222
  export const se_DescribeElasticsearchDomainCommand = async (input, context) => {
352
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
223
+ const b = rb(input, context);
353
224
  const headers = {};
354
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}";
355
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
225
+ b.bp("/2015-01-01/es/domain/{DomainName}");
226
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
356
227
  let body;
357
- return new __HttpRequest({
358
- protocol,
359
- hostname,
360
- port,
361
- method: "GET",
362
- headers,
363
- path: resolvedPath,
364
- body,
365
- });
228
+ b.m("GET").h(headers).b(body);
229
+ return b.build();
366
230
  };
367
231
  export const se_DescribeElasticsearchDomainConfigCommand = async (input, context) => {
368
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
232
+ const b = rb(input, context);
369
233
  const headers = {};
370
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}/config";
371
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
234
+ b.bp("/2015-01-01/es/domain/{DomainName}/config");
235
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
372
236
  let body;
373
- return new __HttpRequest({
374
- protocol,
375
- hostname,
376
- port,
377
- method: "GET",
378
- headers,
379
- path: resolvedPath,
380
- body,
381
- });
237
+ b.m("GET").h(headers).b(body);
238
+ return b.build();
382
239
  };
383
240
  export const se_DescribeElasticsearchDomainsCommand = async (input, context) => {
384
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
241
+ const b = rb(input, context);
385
242
  const headers = {
386
243
  "content-type": "application/json",
387
244
  };
388
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain-info";
245
+ b.bp("/2015-01-01/es/domain-info");
389
246
  let body;
390
247
  body = JSON.stringify(take(input, {
391
248
  DomainNames: (_) => _json(_),
392
249
  }));
393
- return new __HttpRequest({
394
- protocol,
395
- hostname,
396
- port,
397
- method: "POST",
398
- headers,
399
- path: resolvedPath,
400
- body,
401
- });
250
+ b.m("POST").h(headers).b(body);
251
+ return b.build();
402
252
  };
403
253
  export const se_DescribeElasticsearchInstanceTypeLimitsCommand = async (input, context) => {
404
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
254
+ const b = rb(input, context);
405
255
  const headers = {};
406
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
407
- "/2015-01-01/es/instanceTypeLimits/{ElasticsearchVersion}/{InstanceType}";
408
- resolvedPath = __resolvedPath(resolvedPath, input, "InstanceType", () => input.InstanceType, "{InstanceType}", false);
409
- resolvedPath = __resolvedPath(resolvedPath, input, "ElasticsearchVersion", () => input.ElasticsearchVersion, "{ElasticsearchVersion}", false);
256
+ b.bp("/2015-01-01/es/instanceTypeLimits/{ElasticsearchVersion}/{InstanceType}");
257
+ b.p("InstanceType", () => input.InstanceType, "{InstanceType}", false);
258
+ b.p("ElasticsearchVersion", () => input.ElasticsearchVersion, "{ElasticsearchVersion}", false);
410
259
  const query = map({
411
- domainName: [, input.DomainName],
260
+ [_dN]: [, input[_DN]],
412
261
  });
413
262
  let body;
414
- return new __HttpRequest({
415
- protocol,
416
- hostname,
417
- port,
418
- method: "GET",
419
- headers,
420
- path: resolvedPath,
421
- query,
422
- body,
423
- });
263
+ b.m("GET").h(headers).q(query).b(body);
264
+ return b.build();
424
265
  };
425
266
  export const se_DescribeInboundCrossClusterSearchConnectionsCommand = async (input, context) => {
426
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
267
+ const b = rb(input, context);
427
268
  const headers = {
428
269
  "content-type": "application/json",
429
270
  };
430
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
431
- "/2015-01-01/es/ccs/inboundConnection/search";
271
+ b.bp("/2015-01-01/es/ccs/inboundConnection/search");
432
272
  let body;
433
273
  body = JSON.stringify(take(input, {
434
274
  Filters: (_) => _json(_),
435
275
  MaxResults: [],
436
276
  NextToken: [],
437
277
  }));
438
- return new __HttpRequest({
439
- protocol,
440
- hostname,
441
- port,
442
- method: "POST",
443
- headers,
444
- path: resolvedPath,
445
- body,
446
- });
278
+ b.m("POST").h(headers).b(body);
279
+ return b.build();
447
280
  };
448
281
  export const se_DescribeOutboundCrossClusterSearchConnectionsCommand = async (input, context) => {
449
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
282
+ const b = rb(input, context);
450
283
  const headers = {
451
284
  "content-type": "application/json",
452
285
  };
453
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
454
- "/2015-01-01/es/ccs/outboundConnection/search";
286
+ b.bp("/2015-01-01/es/ccs/outboundConnection/search");
455
287
  let body;
456
288
  body = JSON.stringify(take(input, {
457
289
  Filters: (_) => _json(_),
458
290
  MaxResults: [],
459
291
  NextToken: [],
460
292
  }));
461
- return new __HttpRequest({
462
- protocol,
463
- hostname,
464
- port,
465
- method: "POST",
466
- headers,
467
- path: resolvedPath,
468
- body,
469
- });
293
+ b.m("POST").h(headers).b(body);
294
+ return b.build();
470
295
  };
471
296
  export const se_DescribePackagesCommand = async (input, context) => {
472
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
297
+ const b = rb(input, context);
473
298
  const headers = {
474
299
  "content-type": "application/json",
475
300
  };
476
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/describe";
301
+ b.bp("/2015-01-01/packages/describe");
477
302
  let body;
478
303
  body = JSON.stringify(take(input, {
479
304
  Filters: (_) => _json(_),
480
305
  MaxResults: [],
481
306
  NextToken: [],
482
307
  }));
483
- return new __HttpRequest({
484
- protocol,
485
- hostname,
486
- port,
487
- method: "POST",
488
- headers,
489
- path: resolvedPath,
490
- body,
491
- });
308
+ b.m("POST").h(headers).b(body);
309
+ return b.build();
492
310
  };
493
311
  export const se_DescribeReservedElasticsearchInstanceOfferingsCommand = async (input, context) => {
494
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
312
+ const b = rb(input, context);
495
313
  const headers = {};
496
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/reservedInstanceOfferings";
314
+ b.bp("/2015-01-01/es/reservedInstanceOfferings");
497
315
  const query = map({
498
- offeringId: [, input.ReservedElasticsearchInstanceOfferingId],
499
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
500
- nextToken: [, input.NextToken],
316
+ [_oI]: [, input[_REIOI]],
317
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
318
+ [_nT]: [, input[_NT]],
501
319
  });
502
320
  let body;
503
- return new __HttpRequest({
504
- protocol,
505
- hostname,
506
- port,
507
- method: "GET",
508
- headers,
509
- path: resolvedPath,
510
- query,
511
- body,
512
- });
321
+ b.m("GET").h(headers).q(query).b(body);
322
+ return b.build();
513
323
  };
514
324
  export const se_DescribeReservedElasticsearchInstancesCommand = async (input, context) => {
515
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
325
+ const b = rb(input, context);
516
326
  const headers = {};
517
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/reservedInstances";
327
+ b.bp("/2015-01-01/es/reservedInstances");
518
328
  const query = map({
519
- reservationId: [, input.ReservedElasticsearchInstanceId],
520
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
521
- nextToken: [, input.NextToken],
329
+ [_rI]: [, input[_REII]],
330
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
331
+ [_nT]: [, input[_NT]],
522
332
  });
523
333
  let body;
524
- return new __HttpRequest({
525
- protocol,
526
- hostname,
527
- port,
528
- method: "GET",
529
- headers,
530
- path: resolvedPath,
531
- query,
532
- body,
533
- });
334
+ b.m("GET").h(headers).q(query).b(body);
335
+ return b.build();
534
336
  };
535
337
  export const se_DescribeVpcEndpointsCommand = async (input, context) => {
536
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
338
+ const b = rb(input, context);
537
339
  const headers = {
538
340
  "content-type": "application/json",
539
341
  };
540
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints/describe";
342
+ b.bp("/2015-01-01/es/vpcEndpoints/describe");
541
343
  let body;
542
344
  body = JSON.stringify(take(input, {
543
345
  VpcEndpointIds: (_) => _json(_),
544
346
  }));
545
- return new __HttpRequest({
546
- protocol,
547
- hostname,
548
- port,
549
- method: "POST",
550
- headers,
551
- path: resolvedPath,
552
- body,
553
- });
347
+ b.m("POST").h(headers).b(body);
348
+ return b.build();
554
349
  };
555
350
  export const se_DissociatePackageCommand = async (input, context) => {
556
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
351
+ const b = rb(input, context);
557
352
  const headers = {};
558
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
559
- "/2015-01-01/packages/dissociate/{PackageID}/{DomainName}";
560
- resolvedPath = __resolvedPath(resolvedPath, input, "PackageID", () => input.PackageID, "{PackageID}", false);
561
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
353
+ b.bp("/2015-01-01/packages/dissociate/{PackageID}/{DomainName}");
354
+ b.p("PackageID", () => input.PackageID, "{PackageID}", false);
355
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
562
356
  let body;
563
- return new __HttpRequest({
564
- protocol,
565
- hostname,
566
- port,
567
- method: "POST",
568
- headers,
569
- path: resolvedPath,
570
- body,
571
- });
357
+ b.m("POST").h(headers).b(body);
358
+ return b.build();
572
359
  };
573
360
  export const se_GetCompatibleElasticsearchVersionsCommand = async (input, context) => {
574
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
361
+ const b = rb(input, context);
575
362
  const headers = {};
576
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/compatibleVersions";
363
+ b.bp("/2015-01-01/es/compatibleVersions");
577
364
  const query = map({
578
- domainName: [, input.DomainName],
365
+ [_dN]: [, input[_DN]],
579
366
  });
580
367
  let body;
581
- return new __HttpRequest({
582
- protocol,
583
- hostname,
584
- port,
585
- method: "GET",
586
- headers,
587
- path: resolvedPath,
588
- query,
589
- body,
590
- });
368
+ b.m("GET").h(headers).q(query).b(body);
369
+ return b.build();
591
370
  };
592
371
  export const se_GetPackageVersionHistoryCommand = async (input, context) => {
593
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
372
+ const b = rb(input, context);
594
373
  const headers = {};
595
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}/history";
596
- resolvedPath = __resolvedPath(resolvedPath, input, "PackageID", () => input.PackageID, "{PackageID}", false);
374
+ b.bp("/2015-01-01/packages/{PackageID}/history");
375
+ b.p("PackageID", () => input.PackageID, "{PackageID}", false);
597
376
  const query = map({
598
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
599
- nextToken: [, input.NextToken],
377
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
378
+ [_nT]: [, input[_NT]],
600
379
  });
601
380
  let body;
602
- return new __HttpRequest({
603
- protocol,
604
- hostname,
605
- port,
606
- method: "GET",
607
- headers,
608
- path: resolvedPath,
609
- query,
610
- body,
611
- });
381
+ b.m("GET").h(headers).q(query).b(body);
382
+ return b.build();
612
383
  };
613
384
  export const se_GetUpgradeHistoryCommand = async (input, context) => {
614
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
385
+ const b = rb(input, context);
615
386
  const headers = {};
616
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
617
- "/2015-01-01/es/upgradeDomain/{DomainName}/history";
618
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
387
+ b.bp("/2015-01-01/es/upgradeDomain/{DomainName}/history");
388
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
619
389
  const query = map({
620
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
621
- nextToken: [, input.NextToken],
390
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
391
+ [_nT]: [, input[_NT]],
622
392
  });
623
393
  let body;
624
- return new __HttpRequest({
625
- protocol,
626
- hostname,
627
- port,
628
- method: "GET",
629
- headers,
630
- path: resolvedPath,
631
- query,
632
- body,
633
- });
394
+ b.m("GET").h(headers).q(query).b(body);
395
+ return b.build();
634
396
  };
635
397
  export const se_GetUpgradeStatusCommand = async (input, context) => {
636
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
398
+ const b = rb(input, context);
637
399
  const headers = {};
638
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
639
- "/2015-01-01/es/upgradeDomain/{DomainName}/status";
640
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
400
+ b.bp("/2015-01-01/es/upgradeDomain/{DomainName}/status");
401
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
641
402
  let body;
642
- return new __HttpRequest({
643
- protocol,
644
- hostname,
645
- port,
646
- method: "GET",
647
- headers,
648
- path: resolvedPath,
649
- body,
650
- });
403
+ b.m("GET").h(headers).b(body);
404
+ return b.build();
651
405
  };
652
406
  export const se_ListDomainNamesCommand = async (input, context) => {
653
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
407
+ const b = rb(input, context);
654
408
  const headers = {};
655
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/domain";
409
+ b.bp("/2015-01-01/domain");
656
410
  const query = map({
657
- engineType: [, input.EngineType],
411
+ [_eT]: [, input[_ET]],
658
412
  });
659
413
  let body;
660
- return new __HttpRequest({
661
- protocol,
662
- hostname,
663
- port,
664
- method: "GET",
665
- headers,
666
- path: resolvedPath,
667
- query,
668
- body,
669
- });
414
+ b.m("GET").h(headers).q(query).b(body);
415
+ return b.build();
670
416
  };
671
417
  export const se_ListDomainsForPackageCommand = async (input, context) => {
672
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
418
+ const b = rb(input, context);
673
419
  const headers = {};
674
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}/domains";
675
- resolvedPath = __resolvedPath(resolvedPath, input, "PackageID", () => input.PackageID, "{PackageID}", false);
420
+ b.bp("/2015-01-01/packages/{PackageID}/domains");
421
+ b.p("PackageID", () => input.PackageID, "{PackageID}", false);
676
422
  const query = map({
677
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
678
- nextToken: [, input.NextToken],
423
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
424
+ [_nT]: [, input[_NT]],
679
425
  });
680
426
  let body;
681
- return new __HttpRequest({
682
- protocol,
683
- hostname,
684
- port,
685
- method: "GET",
686
- headers,
687
- path: resolvedPath,
688
- query,
689
- body,
690
- });
427
+ b.m("GET").h(headers).q(query).b(body);
428
+ return b.build();
691
429
  };
692
430
  export const se_ListElasticsearchInstanceTypesCommand = async (input, context) => {
693
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
694
432
  const headers = {};
695
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
696
- "/2015-01-01/es/instanceTypes/{ElasticsearchVersion}";
697
- resolvedPath = __resolvedPath(resolvedPath, input, "ElasticsearchVersion", () => input.ElasticsearchVersion, "{ElasticsearchVersion}", false);
433
+ b.bp("/2015-01-01/es/instanceTypes/{ElasticsearchVersion}");
434
+ b.p("ElasticsearchVersion", () => input.ElasticsearchVersion, "{ElasticsearchVersion}", false);
698
435
  const query = map({
699
- domainName: [, input.DomainName],
700
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
701
- nextToken: [, input.NextToken],
436
+ [_dN]: [, input[_DN]],
437
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
438
+ [_nT]: [, input[_NT]],
702
439
  });
703
440
  let body;
704
- return new __HttpRequest({
705
- protocol,
706
- hostname,
707
- port,
708
- method: "GET",
709
- headers,
710
- path: resolvedPath,
711
- query,
712
- body,
713
- });
441
+ b.m("GET").h(headers).q(query).b(body);
442
+ return b.build();
714
443
  };
715
444
  export const se_ListElasticsearchVersionsCommand = async (input, context) => {
716
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
445
+ const b = rb(input, context);
717
446
  const headers = {};
718
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/versions";
447
+ b.bp("/2015-01-01/es/versions");
719
448
  const query = map({
720
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
721
- nextToken: [, input.NextToken],
449
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
450
+ [_nT]: [, input[_NT]],
722
451
  });
723
452
  let body;
724
- return new __HttpRequest({
725
- protocol,
726
- hostname,
727
- port,
728
- method: "GET",
729
- headers,
730
- path: resolvedPath,
731
- query,
732
- body,
733
- });
453
+ b.m("GET").h(headers).q(query).b(body);
454
+ return b.build();
734
455
  };
735
456
  export const se_ListPackagesForDomainCommand = async (input, context) => {
736
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
457
+ const b = rb(input, context);
737
458
  const headers = {};
738
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/domain/{DomainName}/packages";
739
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
459
+ b.bp("/2015-01-01/domain/{DomainName}/packages");
460
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
740
461
  const query = map({
741
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
742
- nextToken: [, input.NextToken],
462
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
463
+ [_nT]: [, input[_NT]],
743
464
  });
744
465
  let body;
745
- return new __HttpRequest({
746
- protocol,
747
- hostname,
748
- port,
749
- method: "GET",
750
- headers,
751
- path: resolvedPath,
752
- query,
753
- body,
754
- });
466
+ b.m("GET").h(headers).q(query).b(body);
467
+ return b.build();
755
468
  };
756
469
  export const se_ListTagsCommand = async (input, context) => {
757
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
470
+ const b = rb(input, context);
758
471
  const headers = {};
759
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags";
472
+ b.bp("/2015-01-01/tags");
760
473
  const query = map({
761
- arn: [, __expectNonNull(input.ARN, `ARN`)],
474
+ [_a]: [, __expectNonNull(input[_ARN], `ARN`)],
762
475
  });
763
476
  let body;
764
- return new __HttpRequest({
765
- protocol,
766
- hostname,
767
- port,
768
- method: "GET",
769
- headers,
770
- path: resolvedPath,
771
- query,
772
- body,
773
- });
477
+ b.m("GET").h(headers).q(query).b(body);
478
+ return b.build();
774
479
  };
775
480
  export const se_ListVpcEndpointAccessCommand = async (input, context) => {
776
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
481
+ const b = rb(input, context);
777
482
  const headers = {};
778
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
779
- "/2015-01-01/es/domain/{DomainName}/listVpcEndpointAccess";
780
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
483
+ b.bp("/2015-01-01/es/domain/{DomainName}/listVpcEndpointAccess");
484
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
781
485
  const query = map({
782
- nextToken: [, input.NextToken],
486
+ [_nT]: [, input[_NT]],
783
487
  });
784
488
  let body;
785
- return new __HttpRequest({
786
- protocol,
787
- hostname,
788
- port,
789
- method: "GET",
790
- headers,
791
- path: resolvedPath,
792
- query,
793
- body,
794
- });
489
+ b.m("GET").h(headers).q(query).b(body);
490
+ return b.build();
795
491
  };
796
492
  export const se_ListVpcEndpointsCommand = async (input, context) => {
797
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
493
+ const b = rb(input, context);
798
494
  const headers = {};
799
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints";
495
+ b.bp("/2015-01-01/es/vpcEndpoints");
800
496
  const query = map({
801
- nextToken: [, input.NextToken],
497
+ [_nT]: [, input[_NT]],
802
498
  });
803
499
  let body;
804
- return new __HttpRequest({
805
- protocol,
806
- hostname,
807
- port,
808
- method: "GET",
809
- headers,
810
- path: resolvedPath,
811
- query,
812
- body,
813
- });
500
+ b.m("GET").h(headers).q(query).b(body);
501
+ return b.build();
814
502
  };
815
503
  export const se_ListVpcEndpointsForDomainCommand = async (input, context) => {
816
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
504
+ const b = rb(input, context);
817
505
  const headers = {};
818
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
819
- "/2015-01-01/es/domain/{DomainName}/vpcEndpoints";
820
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
506
+ b.bp("/2015-01-01/es/domain/{DomainName}/vpcEndpoints");
507
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
821
508
  const query = map({
822
- nextToken: [, input.NextToken],
509
+ [_nT]: [, input[_NT]],
823
510
  });
824
511
  let body;
825
- return new __HttpRequest({
826
- protocol,
827
- hostname,
828
- port,
829
- method: "GET",
830
- headers,
831
- path: resolvedPath,
832
- query,
833
- body,
834
- });
512
+ b.m("GET").h(headers).q(query).b(body);
513
+ return b.build();
835
514
  };
836
515
  export const se_PurchaseReservedElasticsearchInstanceOfferingCommand = async (input, context) => {
837
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
516
+ const b = rb(input, context);
838
517
  const headers = {
839
518
  "content-type": "application/json",
840
519
  };
841
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
842
- "/2015-01-01/es/purchaseReservedInstanceOffering";
520
+ b.bp("/2015-01-01/es/purchaseReservedInstanceOffering");
843
521
  let body;
844
522
  body = JSON.stringify(take(input, {
845
523
  InstanceCount: [],
846
524
  ReservationName: [],
847
525
  ReservedElasticsearchInstanceOfferingId: [],
848
526
  }));
849
- return new __HttpRequest({
850
- protocol,
851
- hostname,
852
- port,
853
- method: "POST",
854
- headers,
855
- path: resolvedPath,
856
- body,
857
- });
527
+ b.m("POST").h(headers).b(body);
528
+ return b.build();
858
529
  };
859
530
  export const se_RejectInboundCrossClusterSearchConnectionCommand = async (input, context) => {
860
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
531
+ const b = rb(input, context);
861
532
  const headers = {};
862
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
863
- "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/reject";
864
- resolvedPath = __resolvedPath(resolvedPath, input, "CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
533
+ b.bp("/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/reject");
534
+ b.p("CrossClusterSearchConnectionId", () => input.CrossClusterSearchConnectionId, "{CrossClusterSearchConnectionId}", false);
865
535
  let body;
866
- return new __HttpRequest({
867
- protocol,
868
- hostname,
869
- port,
870
- method: "PUT",
871
- headers,
872
- path: resolvedPath,
873
- body,
874
- });
536
+ b.m("PUT").h(headers).b(body);
537
+ return b.build();
875
538
  };
876
539
  export const se_RemoveTagsCommand = async (input, context) => {
877
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = rb(input, context);
878
541
  const headers = {
879
542
  "content-type": "application/json",
880
543
  };
881
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags-removal";
544
+ b.bp("/2015-01-01/tags-removal");
882
545
  let body;
883
546
  body = JSON.stringify(take(input, {
884
547
  ARN: [],
885
548
  TagKeys: (_) => _json(_),
886
549
  }));
887
- return new __HttpRequest({
888
- protocol,
889
- hostname,
890
- port,
891
- method: "POST",
892
- headers,
893
- path: resolvedPath,
894
- body,
895
- });
550
+ b.m("POST").h(headers).b(body);
551
+ return b.build();
896
552
  };
897
553
  export const se_RevokeVpcEndpointAccessCommand = async (input, context) => {
898
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
554
+ const b = rb(input, context);
899
555
  const headers = {
900
556
  "content-type": "application/json",
901
557
  };
902
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
903
- "/2015-01-01/es/domain/{DomainName}/revokeVpcEndpointAccess";
904
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
558
+ b.bp("/2015-01-01/es/domain/{DomainName}/revokeVpcEndpointAccess");
559
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
905
560
  let body;
906
561
  body = JSON.stringify(take(input, {
907
562
  Account: [],
908
563
  }));
909
- return new __HttpRequest({
910
- protocol,
911
- hostname,
912
- port,
913
- method: "POST",
914
- headers,
915
- path: resolvedPath,
916
- body,
917
- });
564
+ b.m("POST").h(headers).b(body);
565
+ return b.build();
918
566
  };
919
567
  export const se_StartElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
920
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
568
+ const b = rb(input, context);
921
569
  const headers = {
922
570
  "content-type": "application/json",
923
571
  };
924
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
925
- "/2015-01-01/es/serviceSoftwareUpdate/start";
572
+ b.bp("/2015-01-01/es/serviceSoftwareUpdate/start");
926
573
  let body;
927
574
  body = JSON.stringify(take(input, {
928
575
  DomainName: [],
929
576
  }));
930
- return new __HttpRequest({
931
- protocol,
932
- hostname,
933
- port,
934
- method: "POST",
935
- headers,
936
- path: resolvedPath,
937
- body,
938
- });
577
+ b.m("POST").h(headers).b(body);
578
+ return b.build();
939
579
  };
940
580
  export const se_UpdateElasticsearchDomainConfigCommand = async (input, context) => {
941
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
581
+ const b = rb(input, context);
942
582
  const headers = {
943
583
  "content-type": "application/json",
944
584
  };
945
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}/config";
946
- resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
585
+ b.bp("/2015-01-01/es/domain/{DomainName}/config");
586
+ b.p("DomainName", () => input.DomainName, "{DomainName}", false);
947
587
  let body;
948
588
  body = JSON.stringify(take(input, {
949
589
  AccessPolicies: [],
@@ -961,22 +601,15 @@ export const se_UpdateElasticsearchDomainConfigCommand = async (input, context)
961
601
  SnapshotOptions: (_) => _json(_),
962
602
  VPCOptions: (_) => _json(_),
963
603
  }));
964
- return new __HttpRequest({
965
- protocol,
966
- hostname,
967
- port,
968
- method: "POST",
969
- headers,
970
- path: resolvedPath,
971
- body,
972
- });
604
+ b.m("POST").h(headers).b(body);
605
+ return b.build();
973
606
  };
974
607
  export const se_UpdatePackageCommand = async (input, context) => {
975
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
608
+ const b = rb(input, context);
976
609
  const headers = {
977
610
  "content-type": "application/json",
978
611
  };
979
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/update";
612
+ b.bp("/2015-01-01/packages/update");
980
613
  let body;
981
614
  body = JSON.stringify(take(input, {
982
615
  CommitMessage: [],
@@ -984,58 +617,37 @@ export const se_UpdatePackageCommand = async (input, context) => {
984
617
  PackageID: [],
985
618
  PackageSource: (_) => _json(_),
986
619
  }));
987
- return new __HttpRequest({
988
- protocol,
989
- hostname,
990
- port,
991
- method: "POST",
992
- headers,
993
- path: resolvedPath,
994
- body,
995
- });
620
+ b.m("POST").h(headers).b(body);
621
+ return b.build();
996
622
  };
997
623
  export const se_UpdateVpcEndpointCommand = async (input, context) => {
998
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
624
+ const b = rb(input, context);
999
625
  const headers = {
1000
626
  "content-type": "application/json",
1001
627
  };
1002
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints/update";
628
+ b.bp("/2015-01-01/es/vpcEndpoints/update");
1003
629
  let body;
1004
630
  body = JSON.stringify(take(input, {
1005
631
  VpcEndpointId: [],
1006
632
  VpcOptions: (_) => _json(_),
1007
633
  }));
1008
- return new __HttpRequest({
1009
- protocol,
1010
- hostname,
1011
- port,
1012
- method: "POST",
1013
- headers,
1014
- path: resolvedPath,
1015
- body,
1016
- });
634
+ b.m("POST").h(headers).b(body);
635
+ return b.build();
1017
636
  };
1018
637
  export const se_UpgradeElasticsearchDomainCommand = async (input, context) => {
1019
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
638
+ const b = rb(input, context);
1020
639
  const headers = {
1021
640
  "content-type": "application/json",
1022
641
  };
1023
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/upgradeDomain";
642
+ b.bp("/2015-01-01/es/upgradeDomain");
1024
643
  let body;
1025
644
  body = JSON.stringify(take(input, {
1026
645
  DomainName: [],
1027
646
  PerformCheckOnly: [],
1028
647
  TargetVersion: [],
1029
648
  }));
1030
- return new __HttpRequest({
1031
- protocol,
1032
- hostname,
1033
- port,
1034
- method: "POST",
1035
- headers,
1036
- path: resolvedPath,
1037
- body,
1038
- });
649
+ b.m("POST").h(headers).b(body);
650
+ return b.build();
1039
651
  };
1040
652
  export const de_AcceptInboundCrossClusterSearchConnectionCommand = async (output, context) => {
1041
653
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3793,6 +3405,22 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3793
3405
  value !== "" &&
3794
3406
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3795
3407
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3408
+ const _ARN = "ARN";
3409
+ const _CI = "ChangeId";
3410
+ const _DN = "DomainName";
3411
+ const _ET = "EngineType";
3412
+ const _MR = "MaxResults";
3413
+ const _NT = "NextToken";
3414
+ const _REII = "ReservedElasticsearchInstanceId";
3415
+ const _REIOI = "ReservedElasticsearchInstanceOfferingId";
3416
+ const _a = "arn";
3417
+ const _c = "changeid";
3418
+ const _dN = "domainName";
3419
+ const _eT = "engineType";
3420
+ const _mR = "maxResults";
3421
+ const _nT = "nextToken";
3422
+ const _oI = "offeringId";
3423
+ const _rI = "reservationId";
3796
3424
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3797
3425
  if (encoded.length) {
3798
3426
  return JSON.parse(encoded);