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