@aws-sdk/client-neptune-graph 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 +124 -281
  2. package/dist-es/protocols/Aws_restJson1.js +125 -282
  3. package/package.json +5 -4
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -2,33 +2,26 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.de_UpdateGraphCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_RestoreGraphFromSnapshotCommand = exports.de_ResetGraphCommand = exports.de_ListTagsForResourceCommand = exports.de_ListPrivateGraphEndpointsCommand = exports.de_ListImportTasksCommand = exports.de_ListGraphSnapshotsCommand = exports.de_ListGraphsCommand = exports.de_GetPrivateGraphEndpointCommand = exports.de_GetImportTaskCommand = exports.de_GetGraphSnapshotCommand = exports.de_GetGraphCommand = exports.de_DeletePrivateGraphEndpointCommand = exports.de_DeleteGraphSnapshotCommand = exports.de_DeleteGraphCommand = exports.de_CreatePrivateGraphEndpointCommand = exports.de_CreateGraphUsingImportTaskCommand = exports.de_CreateGraphSnapshotCommand = exports.de_CreateGraphCommand = exports.de_CancelImportTaskCommand = exports.se_UpdateGraphCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = exports.se_RestoreGraphFromSnapshotCommand = exports.se_ResetGraphCommand = exports.se_ListTagsForResourceCommand = exports.se_ListPrivateGraphEndpointsCommand = exports.se_ListImportTasksCommand = exports.se_ListGraphSnapshotsCommand = exports.se_ListGraphsCommand = exports.se_GetPrivateGraphEndpointCommand = exports.se_GetImportTaskCommand = exports.se_GetGraphSnapshotCommand = exports.se_GetGraphCommand = exports.se_DeletePrivateGraphEndpointCommand = exports.se_DeleteGraphSnapshotCommand = exports.se_DeleteGraphCommand = exports.se_CreatePrivateGraphEndpointCommand = exports.se_CreateGraphUsingImportTaskCommand = exports.se_CreateGraphSnapshotCommand = exports.se_CreateGraphCommand = exports.se_CancelImportTaskCommand = void 0;
4
4
  const core_1 = require("@aws-sdk/core");
5
- const protocol_http_1 = require("@smithy/protocol-http");
5
+ const core_2 = require("@smithy/core");
6
6
  const smithy_client_1 = require("@smithy/smithy-client");
7
7
  const models_0_1 = require("../models/models_0");
8
8
  const NeptuneGraphServiceException_1 = require("../models/NeptuneGraphServiceException");
9
9
  const se_CancelImportTaskCommand = async (input, context) => {
10
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
10
+ const b = (0, core_2.requestBuilder)(input, context);
11
11
  const headers = {};
12
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks/{taskIdentifier}";
13
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
12
+ b.bp("/importtasks/{taskIdentifier}");
13
+ b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
14
14
  let body;
15
- return new protocol_http_1.HttpRequest({
16
- protocol,
17
- hostname,
18
- port,
19
- method: "DELETE",
20
- headers,
21
- path: resolvedPath,
22
- body,
23
- });
15
+ b.m("DELETE").h(headers).b(body);
16
+ return b.build();
24
17
  };
25
18
  exports.se_CancelImportTaskCommand = se_CancelImportTaskCommand;
26
19
  const se_CreateGraphCommand = async (input, context) => {
27
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
20
+ const b = (0, core_2.requestBuilder)(input, context);
28
21
  const headers = {
29
22
  "content-type": "application/json",
30
23
  };
31
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs";
24
+ b.bp("/graphs");
32
25
  let body;
33
26
  body = JSON.stringify((0, smithy_client_1.take)(input, {
34
27
  deletionProtection: [],
@@ -40,46 +33,32 @@ const se_CreateGraphCommand = async (input, context) => {
40
33
  tags: (_) => (0, smithy_client_1._json)(_),
41
34
  vectorSearchConfiguration: (_) => (0, smithy_client_1._json)(_),
42
35
  }));
43
- return new protocol_http_1.HttpRequest({
44
- protocol,
45
- hostname,
46
- port,
47
- method: "POST",
48
- headers,
49
- path: resolvedPath,
50
- body,
51
- });
36
+ b.m("POST").h(headers).b(body);
37
+ return b.build();
52
38
  };
53
39
  exports.se_CreateGraphCommand = se_CreateGraphCommand;
54
40
  const se_CreateGraphSnapshotCommand = async (input, context) => {
55
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
41
+ const b = (0, core_2.requestBuilder)(input, context);
56
42
  const headers = {
57
43
  "content-type": "application/json",
58
44
  };
59
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots";
45
+ b.bp("/snapshots");
60
46
  let body;
61
47
  body = JSON.stringify((0, smithy_client_1.take)(input, {
62
48
  graphIdentifier: [],
63
49
  snapshotName: [],
64
50
  tags: (_) => (0, smithy_client_1._json)(_),
65
51
  }));
66
- return new protocol_http_1.HttpRequest({
67
- protocol,
68
- hostname,
69
- port,
70
- method: "POST",
71
- headers,
72
- path: resolvedPath,
73
- body,
74
- });
52
+ b.m("POST").h(headers).b(body);
53
+ return b.build();
75
54
  };
76
55
  exports.se_CreateGraphSnapshotCommand = se_CreateGraphSnapshotCommand;
77
56
  const se_CreateGraphUsingImportTaskCommand = async (input, context) => {
78
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
57
+ const b = (0, core_2.requestBuilder)(input, context);
79
58
  const headers = {
80
59
  "content-type": "application/json",
81
60
  };
82
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks";
61
+ b.bp("/importtasks");
83
62
  let body;
84
63
  body = JSON.stringify((0, smithy_client_1.take)(input, {
85
64
  deletionProtection: [],
@@ -97,300 +76,188 @@ const se_CreateGraphUsingImportTaskCommand = async (input, context) => {
97
76
  tags: (_) => (0, smithy_client_1._json)(_),
98
77
  vectorSearchConfiguration: (_) => (0, smithy_client_1._json)(_),
99
78
  }));
100
- return new protocol_http_1.HttpRequest({
101
- protocol,
102
- hostname,
103
- port,
104
- method: "POST",
105
- headers,
106
- path: resolvedPath,
107
- body,
108
- });
79
+ b.m("POST").h(headers).b(body);
80
+ return b.build();
109
81
  };
110
82
  exports.se_CreateGraphUsingImportTaskCommand = se_CreateGraphUsingImportTaskCommand;
111
83
  const se_CreatePrivateGraphEndpointCommand = async (input, context) => {
112
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
84
+ const b = (0, core_2.requestBuilder)(input, context);
113
85
  const headers = {
114
86
  "content-type": "application/json",
115
87
  };
116
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}/endpoints";
117
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
88
+ b.bp("/graphs/{graphIdentifier}/endpoints");
89
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
118
90
  let body;
119
91
  body = JSON.stringify((0, smithy_client_1.take)(input, {
120
92
  subnetIds: (_) => (0, smithy_client_1._json)(_),
121
93
  vpcId: [],
122
94
  vpcSecurityGroupIds: (_) => (0, smithy_client_1._json)(_),
123
95
  }));
124
- return new protocol_http_1.HttpRequest({
125
- protocol,
126
- hostname,
127
- port,
128
- method: "POST",
129
- headers,
130
- path: resolvedPath,
131
- body,
132
- });
96
+ b.m("POST").h(headers).b(body);
97
+ return b.build();
133
98
  };
134
99
  exports.se_CreatePrivateGraphEndpointCommand = se_CreatePrivateGraphEndpointCommand;
135
100
  const se_DeleteGraphCommand = async (input, context) => {
136
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
101
+ const b = (0, core_2.requestBuilder)(input, context);
137
102
  const headers = {};
138
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
139
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
103
+ b.bp("/graphs/{graphIdentifier}");
104
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
140
105
  const query = (0, smithy_client_1.map)({
141
- skipSnapshot: [(0, smithy_client_1.expectNonNull)(input.skipSnapshot, `skipSnapshot`) != null, () => input.skipSnapshot.toString()],
106
+ [_sS]: [(0, smithy_client_1.expectNonNull)(input.skipSnapshot, `skipSnapshot`) != null, () => input[_sS].toString()],
142
107
  });
143
108
  let body;
144
- return new protocol_http_1.HttpRequest({
145
- protocol,
146
- hostname,
147
- port,
148
- method: "DELETE",
149
- headers,
150
- path: resolvedPath,
151
- query,
152
- body,
153
- });
109
+ b.m("DELETE").h(headers).q(query).b(body);
110
+ return b.build();
154
111
  };
155
112
  exports.se_DeleteGraphCommand = se_DeleteGraphCommand;
156
113
  const se_DeleteGraphSnapshotCommand = async (input, context) => {
157
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
114
+ const b = (0, core_2.requestBuilder)(input, context);
158
115
  const headers = {};
159
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}";
160
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
116
+ b.bp("/snapshots/{snapshotIdentifier}");
117
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
161
118
  let body;
162
- return new protocol_http_1.HttpRequest({
163
- protocol,
164
- hostname,
165
- port,
166
- method: "DELETE",
167
- headers,
168
- path: resolvedPath,
169
- body,
170
- });
119
+ b.m("DELETE").h(headers).b(body);
120
+ return b.build();
171
121
  };
172
122
  exports.se_DeleteGraphSnapshotCommand = se_DeleteGraphSnapshotCommand;
173
123
  const se_DeletePrivateGraphEndpointCommand = async (input, context) => {
174
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
124
+ const b = (0, core_2.requestBuilder)(input, context);
175
125
  const headers = {};
176
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
177
- "/graphs/{graphIdentifier}/endpoints/{vpcId}";
178
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
179
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "vpcId", () => input.vpcId, "{vpcId}", false);
126
+ b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
127
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
128
+ b.p("vpcId", () => input.vpcId, "{vpcId}", false);
180
129
  let body;
181
- return new protocol_http_1.HttpRequest({
182
- protocol,
183
- hostname,
184
- port,
185
- method: "DELETE",
186
- headers,
187
- path: resolvedPath,
188
- body,
189
- });
130
+ b.m("DELETE").h(headers).b(body);
131
+ return b.build();
190
132
  };
191
133
  exports.se_DeletePrivateGraphEndpointCommand = se_DeletePrivateGraphEndpointCommand;
192
134
  const se_GetGraphCommand = async (input, context) => {
193
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
135
+ const b = (0, core_2.requestBuilder)(input, context);
194
136
  const headers = {};
195
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
196
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
137
+ b.bp("/graphs/{graphIdentifier}");
138
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
197
139
  let body;
198
- return new protocol_http_1.HttpRequest({
199
- protocol,
200
- hostname,
201
- port,
202
- method: "GET",
203
- headers,
204
- path: resolvedPath,
205
- body,
206
- });
140
+ b.m("GET").h(headers).b(body);
141
+ return b.build();
207
142
  };
208
143
  exports.se_GetGraphCommand = se_GetGraphCommand;
209
144
  const se_GetGraphSnapshotCommand = async (input, context) => {
210
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
145
+ const b = (0, core_2.requestBuilder)(input, context);
211
146
  const headers = {};
212
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}";
213
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
147
+ b.bp("/snapshots/{snapshotIdentifier}");
148
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
214
149
  let body;
215
- return new protocol_http_1.HttpRequest({
216
- protocol,
217
- hostname,
218
- port,
219
- method: "GET",
220
- headers,
221
- path: resolvedPath,
222
- body,
223
- });
150
+ b.m("GET").h(headers).b(body);
151
+ return b.build();
224
152
  };
225
153
  exports.se_GetGraphSnapshotCommand = se_GetGraphSnapshotCommand;
226
154
  const se_GetImportTaskCommand = async (input, context) => {
227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
155
+ const b = (0, core_2.requestBuilder)(input, context);
228
156
  const headers = {};
229
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks/{taskIdentifier}";
230
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
157
+ b.bp("/importtasks/{taskIdentifier}");
158
+ b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
231
159
  let body;
232
- return new protocol_http_1.HttpRequest({
233
- protocol,
234
- hostname,
235
- port,
236
- method: "GET",
237
- headers,
238
- path: resolvedPath,
239
- body,
240
- });
160
+ b.m("GET").h(headers).b(body);
161
+ return b.build();
241
162
  };
242
163
  exports.se_GetImportTaskCommand = se_GetImportTaskCommand;
243
164
  const se_GetPrivateGraphEndpointCommand = async (input, context) => {
244
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
165
+ const b = (0, core_2.requestBuilder)(input, context);
245
166
  const headers = {};
246
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
247
- "/graphs/{graphIdentifier}/endpoints/{vpcId}";
248
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
249
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "vpcId", () => input.vpcId, "{vpcId}", false);
167
+ b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
168
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
169
+ b.p("vpcId", () => input.vpcId, "{vpcId}", false);
250
170
  let body;
251
- return new protocol_http_1.HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "GET",
256
- headers,
257
- path: resolvedPath,
258
- body,
259
- });
171
+ b.m("GET").h(headers).b(body);
172
+ return b.build();
260
173
  };
261
174
  exports.se_GetPrivateGraphEndpointCommand = se_GetPrivateGraphEndpointCommand;
262
175
  const se_ListGraphsCommand = async (input, context) => {
263
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
176
+ const b = (0, core_2.requestBuilder)(input, context);
264
177
  const headers = {};
265
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs";
178
+ b.bp("/graphs");
266
179
  const query = (0, smithy_client_1.map)({
267
- nextToken: [, input.nextToken],
268
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
180
+ [_nT]: [, input[_nT]],
181
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
269
182
  });
270
183
  let body;
271
- return new protocol_http_1.HttpRequest({
272
- protocol,
273
- hostname,
274
- port,
275
- method: "GET",
276
- headers,
277
- path: resolvedPath,
278
- query,
279
- body,
280
- });
184
+ b.m("GET").h(headers).q(query).b(body);
185
+ return b.build();
281
186
  };
282
187
  exports.se_ListGraphsCommand = se_ListGraphsCommand;
283
188
  const se_ListGraphSnapshotsCommand = async (input, context) => {
284
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = (0, core_2.requestBuilder)(input, context);
285
190
  const headers = {};
286
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots";
191
+ b.bp("/snapshots");
287
192
  const query = (0, smithy_client_1.map)({
288
- graphIdentifier: [, input.graphIdentifier],
289
- nextToken: [, input.nextToken],
290
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
193
+ [_gI]: [, input[_gI]],
194
+ [_nT]: [, input[_nT]],
195
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
291
196
  });
292
197
  let body;
293
- return new protocol_http_1.HttpRequest({
294
- protocol,
295
- hostname,
296
- port,
297
- method: "GET",
298
- headers,
299
- path: resolvedPath,
300
- query,
301
- body,
302
- });
198
+ b.m("GET").h(headers).q(query).b(body);
199
+ return b.build();
303
200
  };
304
201
  exports.se_ListGraphSnapshotsCommand = se_ListGraphSnapshotsCommand;
305
202
  const se_ListImportTasksCommand = async (input, context) => {
306
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
203
+ const b = (0, core_2.requestBuilder)(input, context);
307
204
  const headers = {};
308
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks";
205
+ b.bp("/importtasks");
309
206
  const query = (0, smithy_client_1.map)({
310
- nextToken: [, input.nextToken],
311
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
207
+ [_nT]: [, input[_nT]],
208
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
312
209
  });
313
210
  let body;
314
- return new protocol_http_1.HttpRequest({
315
- protocol,
316
- hostname,
317
- port,
318
- method: "GET",
319
- headers,
320
- path: resolvedPath,
321
- query,
322
- body,
323
- });
211
+ b.m("GET").h(headers).q(query).b(body);
212
+ return b.build();
324
213
  };
325
214
  exports.se_ListImportTasksCommand = se_ListImportTasksCommand;
326
215
  const se_ListPrivateGraphEndpointsCommand = async (input, context) => {
327
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
216
+ const b = (0, core_2.requestBuilder)(input, context);
328
217
  const headers = {};
329
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}/endpoints";
330
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
218
+ b.bp("/graphs/{graphIdentifier}/endpoints");
219
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
331
220
  const query = (0, smithy_client_1.map)({
332
- nextToken: [, input.nextToken],
333
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
221
+ [_nT]: [, input[_nT]],
222
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
334
223
  });
335
224
  let body;
336
- return new protocol_http_1.HttpRequest({
337
- protocol,
338
- hostname,
339
- port,
340
- method: "GET",
341
- headers,
342
- path: resolvedPath,
343
- query,
344
- body,
345
- });
225
+ b.m("GET").h(headers).q(query).b(body);
226
+ return b.build();
346
227
  };
347
228
  exports.se_ListPrivateGraphEndpointsCommand = se_ListPrivateGraphEndpointsCommand;
348
229
  const se_ListTagsForResourceCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
230
+ const b = (0, core_2.requestBuilder)(input, context);
350
231
  const headers = {};
351
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
352
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
232
+ b.bp("/tags/{resourceArn}");
233
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
353
234
  let body;
354
- return new protocol_http_1.HttpRequest({
355
- protocol,
356
- hostname,
357
- port,
358
- method: "GET",
359
- headers,
360
- path: resolvedPath,
361
- body,
362
- });
235
+ b.m("GET").h(headers).b(body);
236
+ return b.build();
363
237
  };
364
238
  exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
365
239
  const se_ResetGraphCommand = async (input, context) => {
366
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
240
+ const b = (0, core_2.requestBuilder)(input, context);
367
241
  const headers = {
368
242
  "content-type": "application/json",
369
243
  };
370
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
371
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
244
+ b.bp("/graphs/{graphIdentifier}");
245
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
372
246
  let body;
373
247
  body = JSON.stringify((0, smithy_client_1.take)(input, {
374
248
  skipSnapshot: [],
375
249
  }));
376
- return new protocol_http_1.HttpRequest({
377
- protocol,
378
- hostname,
379
- port,
380
- method: "PUT",
381
- headers,
382
- path: resolvedPath,
383
- body,
384
- });
250
+ b.m("PUT").h(headers).b(body);
251
+ return b.build();
385
252
  };
386
253
  exports.se_ResetGraphCommand = se_ResetGraphCommand;
387
254
  const se_RestoreGraphFromSnapshotCommand = async (input, context) => {
388
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
255
+ const b = (0, core_2.requestBuilder)(input, context);
389
256
  const headers = {
390
257
  "content-type": "application/json",
391
258
  };
392
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}/restore";
393
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
259
+ b.bp("/snapshots/{snapshotIdentifier}/restore");
260
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
394
261
  let body;
395
262
  body = JSON.stringify((0, smithy_client_1.take)(input, {
396
263
  deletionProtection: [],
@@ -400,85 +267,56 @@ const se_RestoreGraphFromSnapshotCommand = async (input, context) => {
400
267
  replicaCount: [],
401
268
  tags: (_) => (0, smithy_client_1._json)(_),
402
269
  }));
403
- return new protocol_http_1.HttpRequest({
404
- protocol,
405
- hostname,
406
- port,
407
- method: "POST",
408
- headers,
409
- path: resolvedPath,
410
- body,
411
- });
270
+ b.m("POST").h(headers).b(body);
271
+ return b.build();
412
272
  };
413
273
  exports.se_RestoreGraphFromSnapshotCommand = se_RestoreGraphFromSnapshotCommand;
414
274
  const se_TagResourceCommand = async (input, context) => {
415
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
275
+ const b = (0, core_2.requestBuilder)(input, context);
416
276
  const headers = {
417
277
  "content-type": "application/json",
418
278
  };
419
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
420
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
279
+ b.bp("/tags/{resourceArn}");
280
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
421
281
  let body;
422
282
  body = JSON.stringify((0, smithy_client_1.take)(input, {
423
283
  tags: (_) => (0, smithy_client_1._json)(_),
424
284
  }));
425
- return new protocol_http_1.HttpRequest({
426
- protocol,
427
- hostname,
428
- port,
429
- method: "POST",
430
- headers,
431
- path: resolvedPath,
432
- body,
433
- });
285
+ b.m("POST").h(headers).b(body);
286
+ return b.build();
434
287
  };
435
288
  exports.se_TagResourceCommand = se_TagResourceCommand;
436
289
  const se_UntagResourceCommand = async (input, context) => {
437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
290
+ const b = (0, core_2.requestBuilder)(input, context);
438
291
  const headers = {};
439
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
440
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
292
+ b.bp("/tags/{resourceArn}");
293
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
441
294
  const query = (0, smithy_client_1.map)({
442
- tagKeys: [
295
+ [_tK]: [
443
296
  (0, smithy_client_1.expectNonNull)(input.tagKeys, `tagKeys`) != null,
444
- () => (input.tagKeys || []).map((_entry) => _entry),
297
+ () => (input[_tK] || []).map((_entry) => _entry),
445
298
  ],
446
299
  });
447
300
  let body;
448
- return new protocol_http_1.HttpRequest({
449
- protocol,
450
- hostname,
451
- port,
452
- method: "DELETE",
453
- headers,
454
- path: resolvedPath,
455
- query,
456
- body,
457
- });
301
+ b.m("DELETE").h(headers).q(query).b(body);
302
+ return b.build();
458
303
  };
459
304
  exports.se_UntagResourceCommand = se_UntagResourceCommand;
460
305
  const se_UpdateGraphCommand = async (input, context) => {
461
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
306
+ const b = (0, core_2.requestBuilder)(input, context);
462
307
  const headers = {
463
308
  "content-type": "application/json",
464
309
  };
465
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
466
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
310
+ b.bp("/graphs/{graphIdentifier}");
311
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
467
312
  let body;
468
313
  body = JSON.stringify((0, smithy_client_1.take)(input, {
469
314
  deletionProtection: [],
470
315
  provisionedMemory: [],
471
316
  publicConnectivity: [],
472
317
  }));
473
- return new protocol_http_1.HttpRequest({
474
- protocol,
475
- hostname,
476
- port,
477
- method: "PATCH",
478
- headers,
479
- path: resolvedPath,
480
- body,
481
- });
318
+ b.m("PATCH").h(headers).b(body);
319
+ return b.build();
482
320
  };
483
321
  exports.se_UpdateGraphCommand = se_UpdateGraphCommand;
484
322
  const de_CancelImportTaskCommand = async (output, context) => {
@@ -1721,6 +1559,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
1721
1559
  value !== "" &&
1722
1560
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
1723
1561
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
1562
+ const _gI = "graphIdentifier";
1563
+ const _mR = "maxResults";
1564
+ const _nT = "nextToken";
1565
+ const _sS = "skipSnapshot";
1566
+ const _tK = "tagKeys";
1724
1567
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
1725
1568
  if (encoded.length) {
1726
1569
  return JSON.parse(encoded);
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,30 +1,23 @@
1
1
  import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
2
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
3
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
2
+ import { requestBuilder as rb } from "@smithy/core";
3
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
4
4
  import { ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
5
5
  import { NeptuneGraphServiceException as __BaseException } from "../models/NeptuneGraphServiceException";
6
6
  export const se_CancelImportTaskCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {};
9
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks/{taskIdentifier}";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
9
+ b.bp("/importtasks/{taskIdentifier}");
10
+ b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
11
11
  let body;
12
- return new __HttpRequest({
13
- protocol,
14
- hostname,
15
- port,
16
- method: "DELETE",
17
- headers,
18
- path: resolvedPath,
19
- body,
20
- });
12
+ b.m("DELETE").h(headers).b(body);
13
+ return b.build();
21
14
  };
22
15
  export const se_CreateGraphCommand = async (input, context) => {
23
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
16
+ const b = rb(input, context);
24
17
  const headers = {
25
18
  "content-type": "application/json",
26
19
  };
27
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs";
20
+ b.bp("/graphs");
28
21
  let body;
29
22
  body = JSON.stringify(take(input, {
30
23
  deletionProtection: [],
@@ -36,44 +29,30 @@ export const se_CreateGraphCommand = async (input, context) => {
36
29
  tags: (_) => _json(_),
37
30
  vectorSearchConfiguration: (_) => _json(_),
38
31
  }));
39
- return new __HttpRequest({
40
- protocol,
41
- hostname,
42
- port,
43
- method: "POST",
44
- headers,
45
- path: resolvedPath,
46
- body,
47
- });
32
+ b.m("POST").h(headers).b(body);
33
+ return b.build();
48
34
  };
49
35
  export const se_CreateGraphSnapshotCommand = async (input, context) => {
50
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
36
+ const b = rb(input, context);
51
37
  const headers = {
52
38
  "content-type": "application/json",
53
39
  };
54
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots";
40
+ b.bp("/snapshots");
55
41
  let body;
56
42
  body = JSON.stringify(take(input, {
57
43
  graphIdentifier: [],
58
44
  snapshotName: [],
59
45
  tags: (_) => _json(_),
60
46
  }));
61
- return new __HttpRequest({
62
- protocol,
63
- hostname,
64
- port,
65
- method: "POST",
66
- headers,
67
- path: resolvedPath,
68
- body,
69
- });
47
+ b.m("POST").h(headers).b(body);
48
+ return b.build();
70
49
  };
71
50
  export const se_CreateGraphUsingImportTaskCommand = async (input, context) => {
72
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
51
+ const b = rb(input, context);
73
52
  const headers = {
74
53
  "content-type": "application/json",
75
54
  };
76
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks";
55
+ b.bp("/importtasks");
77
56
  let body;
78
57
  body = JSON.stringify(take(input, {
79
58
  deletionProtection: [],
@@ -91,285 +70,173 @@ export const se_CreateGraphUsingImportTaskCommand = async (input, context) => {
91
70
  tags: (_) => _json(_),
92
71
  vectorSearchConfiguration: (_) => _json(_),
93
72
  }));
94
- return new __HttpRequest({
95
- protocol,
96
- hostname,
97
- port,
98
- method: "POST",
99
- headers,
100
- path: resolvedPath,
101
- body,
102
- });
73
+ b.m("POST").h(headers).b(body);
74
+ return b.build();
103
75
  };
104
76
  export const se_CreatePrivateGraphEndpointCommand = async (input, context) => {
105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
77
+ const b = rb(input, context);
106
78
  const headers = {
107
79
  "content-type": "application/json",
108
80
  };
109
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}/endpoints";
110
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
81
+ b.bp("/graphs/{graphIdentifier}/endpoints");
82
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
111
83
  let body;
112
84
  body = JSON.stringify(take(input, {
113
85
  subnetIds: (_) => _json(_),
114
86
  vpcId: [],
115
87
  vpcSecurityGroupIds: (_) => _json(_),
116
88
  }));
117
- return new __HttpRequest({
118
- protocol,
119
- hostname,
120
- port,
121
- method: "POST",
122
- headers,
123
- path: resolvedPath,
124
- body,
125
- });
89
+ b.m("POST").h(headers).b(body);
90
+ return b.build();
126
91
  };
127
92
  export const se_DeleteGraphCommand = async (input, context) => {
128
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
93
+ const b = rb(input, context);
129
94
  const headers = {};
130
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
131
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
95
+ b.bp("/graphs/{graphIdentifier}");
96
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
132
97
  const query = map({
133
- skipSnapshot: [__expectNonNull(input.skipSnapshot, `skipSnapshot`) != null, () => input.skipSnapshot.toString()],
98
+ [_sS]: [__expectNonNull(input.skipSnapshot, `skipSnapshot`) != null, () => input[_sS].toString()],
134
99
  });
135
100
  let body;
136
- return new __HttpRequest({
137
- protocol,
138
- hostname,
139
- port,
140
- method: "DELETE",
141
- headers,
142
- path: resolvedPath,
143
- query,
144
- body,
145
- });
101
+ b.m("DELETE").h(headers).q(query).b(body);
102
+ return b.build();
146
103
  };
147
104
  export const se_DeleteGraphSnapshotCommand = async (input, context) => {
148
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
105
+ const b = rb(input, context);
149
106
  const headers = {};
150
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}";
151
- resolvedPath = __resolvedPath(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
107
+ b.bp("/snapshots/{snapshotIdentifier}");
108
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
152
109
  let body;
153
- return new __HttpRequest({
154
- protocol,
155
- hostname,
156
- port,
157
- method: "DELETE",
158
- headers,
159
- path: resolvedPath,
160
- body,
161
- });
110
+ b.m("DELETE").h(headers).b(body);
111
+ return b.build();
162
112
  };
163
113
  export const se_DeletePrivateGraphEndpointCommand = async (input, context) => {
164
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
114
+ const b = rb(input, context);
165
115
  const headers = {};
166
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
167
- "/graphs/{graphIdentifier}/endpoints/{vpcId}";
168
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
169
- resolvedPath = __resolvedPath(resolvedPath, input, "vpcId", () => input.vpcId, "{vpcId}", false);
116
+ b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
117
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
118
+ b.p("vpcId", () => input.vpcId, "{vpcId}", false);
170
119
  let body;
171
- return new __HttpRequest({
172
- protocol,
173
- hostname,
174
- port,
175
- method: "DELETE",
176
- headers,
177
- path: resolvedPath,
178
- body,
179
- });
120
+ b.m("DELETE").h(headers).b(body);
121
+ return b.build();
180
122
  };
181
123
  export const se_GetGraphCommand = async (input, context) => {
182
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
124
+ const b = rb(input, context);
183
125
  const headers = {};
184
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
185
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
126
+ b.bp("/graphs/{graphIdentifier}");
127
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
186
128
  let body;
187
- return new __HttpRequest({
188
- protocol,
189
- hostname,
190
- port,
191
- method: "GET",
192
- headers,
193
- path: resolvedPath,
194
- body,
195
- });
129
+ b.m("GET").h(headers).b(body);
130
+ return b.build();
196
131
  };
197
132
  export const se_GetGraphSnapshotCommand = async (input, context) => {
198
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
133
+ const b = rb(input, context);
199
134
  const headers = {};
200
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}";
201
- resolvedPath = __resolvedPath(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
135
+ b.bp("/snapshots/{snapshotIdentifier}");
136
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
202
137
  let body;
203
- return new __HttpRequest({
204
- protocol,
205
- hostname,
206
- port,
207
- method: "GET",
208
- headers,
209
- path: resolvedPath,
210
- body,
211
- });
138
+ b.m("GET").h(headers).b(body);
139
+ return b.build();
212
140
  };
213
141
  export const se_GetImportTaskCommand = async (input, context) => {
214
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
142
+ const b = rb(input, context);
215
143
  const headers = {};
216
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks/{taskIdentifier}";
217
- resolvedPath = __resolvedPath(resolvedPath, input, "taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
144
+ b.bp("/importtasks/{taskIdentifier}");
145
+ b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
218
146
  let body;
219
- return new __HttpRequest({
220
- protocol,
221
- hostname,
222
- port,
223
- method: "GET",
224
- headers,
225
- path: resolvedPath,
226
- body,
227
- });
147
+ b.m("GET").h(headers).b(body);
148
+ return b.build();
228
149
  };
229
150
  export const se_GetPrivateGraphEndpointCommand = async (input, context) => {
230
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
151
+ const b = rb(input, context);
231
152
  const headers = {};
232
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
233
- "/graphs/{graphIdentifier}/endpoints/{vpcId}";
234
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
235
- resolvedPath = __resolvedPath(resolvedPath, input, "vpcId", () => input.vpcId, "{vpcId}", false);
153
+ b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
154
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
155
+ b.p("vpcId", () => input.vpcId, "{vpcId}", false);
236
156
  let body;
237
- return new __HttpRequest({
238
- protocol,
239
- hostname,
240
- port,
241
- method: "GET",
242
- headers,
243
- path: resolvedPath,
244
- body,
245
- });
157
+ b.m("GET").h(headers).b(body);
158
+ return b.build();
246
159
  };
247
160
  export const se_ListGraphsCommand = async (input, context) => {
248
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
161
+ const b = rb(input, context);
249
162
  const headers = {};
250
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs";
163
+ b.bp("/graphs");
251
164
  const query = map({
252
- nextToken: [, input.nextToken],
253
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
165
+ [_nT]: [, input[_nT]],
166
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
254
167
  });
255
168
  let body;
256
- return new __HttpRequest({
257
- protocol,
258
- hostname,
259
- port,
260
- method: "GET",
261
- headers,
262
- path: resolvedPath,
263
- query,
264
- body,
265
- });
169
+ b.m("GET").h(headers).q(query).b(body);
170
+ return b.build();
266
171
  };
267
172
  export const se_ListGraphSnapshotsCommand = async (input, context) => {
268
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
173
+ const b = rb(input, context);
269
174
  const headers = {};
270
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots";
175
+ b.bp("/snapshots");
271
176
  const query = map({
272
- graphIdentifier: [, input.graphIdentifier],
273
- nextToken: [, input.nextToken],
274
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
177
+ [_gI]: [, input[_gI]],
178
+ [_nT]: [, input[_nT]],
179
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
275
180
  });
276
181
  let body;
277
- return new __HttpRequest({
278
- protocol,
279
- hostname,
280
- port,
281
- method: "GET",
282
- headers,
283
- path: resolvedPath,
284
- query,
285
- body,
286
- });
182
+ b.m("GET").h(headers).q(query).b(body);
183
+ return b.build();
287
184
  };
288
185
  export const se_ListImportTasksCommand = async (input, context) => {
289
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
186
+ const b = rb(input, context);
290
187
  const headers = {};
291
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/importtasks";
188
+ b.bp("/importtasks");
292
189
  const query = map({
293
- nextToken: [, input.nextToken],
294
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
190
+ [_nT]: [, input[_nT]],
191
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
295
192
  });
296
193
  let body;
297
- return new __HttpRequest({
298
- protocol,
299
- hostname,
300
- port,
301
- method: "GET",
302
- headers,
303
- path: resolvedPath,
304
- query,
305
- body,
306
- });
194
+ b.m("GET").h(headers).q(query).b(body);
195
+ return b.build();
307
196
  };
308
197
  export const se_ListPrivateGraphEndpointsCommand = async (input, context) => {
309
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
198
+ const b = rb(input, context);
310
199
  const headers = {};
311
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}/endpoints";
312
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
200
+ b.bp("/graphs/{graphIdentifier}/endpoints");
201
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
313
202
  const query = map({
314
- nextToken: [, input.nextToken],
315
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
203
+ [_nT]: [, input[_nT]],
204
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
316
205
  });
317
206
  let body;
318
- return new __HttpRequest({
319
- protocol,
320
- hostname,
321
- port,
322
- method: "GET",
323
- headers,
324
- path: resolvedPath,
325
- query,
326
- body,
327
- });
207
+ b.m("GET").h(headers).q(query).b(body);
208
+ return b.build();
328
209
  };
329
210
  export const se_ListTagsForResourceCommand = async (input, context) => {
330
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
211
+ const b = rb(input, context);
331
212
  const headers = {};
332
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
333
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
213
+ b.bp("/tags/{resourceArn}");
214
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
334
215
  let body;
335
- return new __HttpRequest({
336
- protocol,
337
- hostname,
338
- port,
339
- method: "GET",
340
- headers,
341
- path: resolvedPath,
342
- body,
343
- });
216
+ b.m("GET").h(headers).b(body);
217
+ return b.build();
344
218
  };
345
219
  export const se_ResetGraphCommand = async (input, context) => {
346
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
220
+ const b = rb(input, context);
347
221
  const headers = {
348
222
  "content-type": "application/json",
349
223
  };
350
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
351
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
224
+ b.bp("/graphs/{graphIdentifier}");
225
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
352
226
  let body;
353
227
  body = JSON.stringify(take(input, {
354
228
  skipSnapshot: [],
355
229
  }));
356
- return new __HttpRequest({
357
- protocol,
358
- hostname,
359
- port,
360
- method: "PUT",
361
- headers,
362
- path: resolvedPath,
363
- body,
364
- });
230
+ b.m("PUT").h(headers).b(body);
231
+ return b.build();
365
232
  };
366
233
  export const se_RestoreGraphFromSnapshotCommand = async (input, context) => {
367
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
234
+ const b = rb(input, context);
368
235
  const headers = {
369
236
  "content-type": "application/json",
370
237
  };
371
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/snapshots/{snapshotIdentifier}/restore";
372
- resolvedPath = __resolvedPath(resolvedPath, input, "snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
238
+ b.bp("/snapshots/{snapshotIdentifier}/restore");
239
+ b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
373
240
  let body;
374
241
  body = JSON.stringify(take(input, {
375
242
  deletionProtection: [],
@@ -379,82 +246,53 @@ export const se_RestoreGraphFromSnapshotCommand = async (input, context) => {
379
246
  replicaCount: [],
380
247
  tags: (_) => _json(_),
381
248
  }));
382
- return new __HttpRequest({
383
- protocol,
384
- hostname,
385
- port,
386
- method: "POST",
387
- headers,
388
- path: resolvedPath,
389
- body,
390
- });
249
+ b.m("POST").h(headers).b(body);
250
+ return b.build();
391
251
  };
392
252
  export const se_TagResourceCommand = async (input, context) => {
393
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
253
+ const b = rb(input, context);
394
254
  const headers = {
395
255
  "content-type": "application/json",
396
256
  };
397
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
398
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
257
+ b.bp("/tags/{resourceArn}");
258
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
399
259
  let body;
400
260
  body = JSON.stringify(take(input, {
401
261
  tags: (_) => _json(_),
402
262
  }));
403
- return new __HttpRequest({
404
- protocol,
405
- hostname,
406
- port,
407
- method: "POST",
408
- headers,
409
- path: resolvedPath,
410
- body,
411
- });
263
+ b.m("POST").h(headers).b(body);
264
+ return b.build();
412
265
  };
413
266
  export const se_UntagResourceCommand = async (input, context) => {
414
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
267
+ const b = rb(input, context);
415
268
  const headers = {};
416
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
417
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
269
+ b.bp("/tags/{resourceArn}");
270
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
418
271
  const query = map({
419
- tagKeys: [
272
+ [_tK]: [
420
273
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
421
- () => (input.tagKeys || []).map((_entry) => _entry),
274
+ () => (input[_tK] || []).map((_entry) => _entry),
422
275
  ],
423
276
  });
424
277
  let body;
425
- return new __HttpRequest({
426
- protocol,
427
- hostname,
428
- port,
429
- method: "DELETE",
430
- headers,
431
- path: resolvedPath,
432
- query,
433
- body,
434
- });
278
+ b.m("DELETE").h(headers).q(query).b(body);
279
+ return b.build();
435
280
  };
436
281
  export const se_UpdateGraphCommand = async (input, context) => {
437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
282
+ const b = rb(input, context);
438
283
  const headers = {
439
284
  "content-type": "application/json",
440
285
  };
441
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/graphs/{graphIdentifier}";
442
- resolvedPath = __resolvedPath(resolvedPath, input, "graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
286
+ b.bp("/graphs/{graphIdentifier}");
287
+ b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
443
288
  let body;
444
289
  body = JSON.stringify(take(input, {
445
290
  deletionProtection: [],
446
291
  provisionedMemory: [],
447
292
  publicConnectivity: [],
448
293
  }));
449
- return new __HttpRequest({
450
- protocol,
451
- hostname,
452
- port,
453
- method: "PATCH",
454
- headers,
455
- path: resolvedPath,
456
- body,
457
- });
294
+ b.m("PATCH").h(headers).b(body);
295
+ return b.build();
458
296
  };
459
297
  export const de_CancelImportTaskCommand = async (output, context) => {
460
298
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1674,6 +1512,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
1674
1512
  value !== "" &&
1675
1513
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
1676
1514
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
1515
+ const _gI = "graphIdentifier";
1516
+ const _mR = "maxResults";
1517
+ const _nT = "nextToken";
1518
+ const _sS = "skipSnapshot";
1519
+ const _tK = "tagKeys";
1677
1520
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
1678
1521
  if (encoded.length) {
1679
1522
  return JSON.parse(encoded);
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-neptune-graph",
3
3
  "description": "AWS SDK for JavaScript Neptune Graph Client for Node.js, Browser and React Native",
4
- "version": "3.474.0",
4
+ "version": "3.477.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,9 +20,9 @@
20
20
  "dependencies": {
21
21
  "@aws-crypto/sha256-browser": "3.0.0",
22
22
  "@aws-crypto/sha256-js": "3.0.0",
23
- "@aws-sdk/client-sts": "3.474.0",
24
- "@aws-sdk/core": "3.474.0",
25
- "@aws-sdk/credential-provider-node": "3.474.0",
23
+ "@aws-sdk/client-sts": "3.477.0",
24
+ "@aws-sdk/core": "3.477.0",
25
+ "@aws-sdk/credential-provider-node": "3.477.0",
26
26
  "@aws-sdk/middleware-host-header": "3.468.0",
27
27
  "@aws-sdk/middleware-logger": "3.468.0",
28
28
  "@aws-sdk/middleware-recursion-detection": "3.468.0",
@@ -34,6 +34,7 @@
34
34
  "@aws-sdk/util-user-agent-browser": "3.468.0",
35
35
  "@aws-sdk/util-user-agent-node": "3.470.0",
36
36
  "@smithy/config-resolver": "^2.0.21",
37
+ "@smithy/core": "^1.2.0",
37
38
  "@smithy/fetch-http-handler": "^2.3.1",
38
39
  "@smithy/hash-node": "^2.0.17",
39
40
  "@smithy/invalid-dependency": "^2.0.15",