@aws-sdk/client-neptunedata 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 +248 -551
  2. package/dist-es/protocols/Aws_restJson1.js +249 -552
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,128 +1,82 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { AccessDeniedException, BadRequestException, BulkLoadIdNotFoundException, CancelledByUserException, ClientTimeoutException, ConcurrentModificationException, ConstraintViolationException, ExpiredStreamException, FailureByQueryException, IllegalArgumentException, InternalFailureException, InvalidArgumentException, InvalidNumericDataException, InvalidParameterException, LoadUrlAccessDeniedException, MalformedQueryException, MemoryLimitExceededException, MethodNotAllowedException, MissingParameterException, MLResourceNotFoundException, ParsingException, PreconditionsFailedException, QueryLimitExceededException, QueryLimitException, QueryTooLargeException, ReadOnlyViolationException, S3Exception, ServerShutdownException, StatisticsNotAvailableException, StreamRecordsNotFoundException, ThrottlingException, TimeLimitExceededException, TooManyRequestsException, UnsupportedOperationException, } from "../models/models_0";
4
4
  import { NeptunedataServiceException as __BaseException } from "../models/NeptunedataServiceException";
5
5
  export const se_CancelGremlinQueryCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {};
8
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status/{queryId}";
9
- resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
8
+ b.bp("/gremlin/status/{queryId}");
9
+ b.p("queryId", () => input.queryId, "{queryId}", false);
10
10
  let body;
11
- return new __HttpRequest({
12
- protocol,
13
- hostname,
14
- port,
15
- method: "DELETE",
16
- headers,
17
- path: resolvedPath,
18
- body,
19
- });
11
+ b.m("DELETE").h(headers).b(body);
12
+ return b.build();
20
13
  };
21
14
  export const se_CancelLoaderJobCommand = async (input, context) => {
22
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
15
+ const b = rb(input, context);
23
16
  const headers = {};
24
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader/{loadId}";
25
- resolvedPath = __resolvedPath(resolvedPath, input, "loadId", () => input.loadId, "{loadId}", false);
17
+ b.bp("/loader/{loadId}");
18
+ b.p("loadId", () => input.loadId, "{loadId}", false);
26
19
  let body;
27
- return new __HttpRequest({
28
- protocol,
29
- hostname,
30
- port,
31
- method: "DELETE",
32
- headers,
33
- path: resolvedPath,
34
- body,
35
- });
20
+ b.m("DELETE").h(headers).b(body);
21
+ return b.build();
36
22
  };
37
23
  export const se_CancelMLDataProcessingJobCommand = async (input, context) => {
38
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
24
+ const b = rb(input, context);
39
25
  const headers = {};
40
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing/{id}";
41
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
26
+ b.bp("/ml/dataprocessing/{id}");
27
+ b.p("id", () => input.id, "{id}", false);
42
28
  const query = map({
43
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
44
- clean: [() => input.clean !== void 0, () => input.clean.toString()],
29
+ [_nIRA]: [, input[_nIRA]],
30
+ [_c]: [() => input.clean !== void 0, () => input[_c].toString()],
45
31
  });
46
32
  let body;
47
- return new __HttpRequest({
48
- protocol,
49
- hostname,
50
- port,
51
- method: "DELETE",
52
- headers,
53
- path: resolvedPath,
54
- query,
55
- body,
56
- });
33
+ b.m("DELETE").h(headers).q(query).b(body);
34
+ return b.build();
57
35
  };
58
36
  export const se_CancelMLModelTrainingJobCommand = async (input, context) => {
59
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
37
+ const b = rb(input, context);
60
38
  const headers = {};
61
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining/{id}";
62
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
39
+ b.bp("/ml/modeltraining/{id}");
40
+ b.p("id", () => input.id, "{id}", false);
63
41
  const query = map({
64
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
65
- clean: [() => input.clean !== void 0, () => input.clean.toString()],
42
+ [_nIRA]: [, input[_nIRA]],
43
+ [_c]: [() => input.clean !== void 0, () => input[_c].toString()],
66
44
  });
67
45
  let body;
68
- return new __HttpRequest({
69
- protocol,
70
- hostname,
71
- port,
72
- method: "DELETE",
73
- headers,
74
- path: resolvedPath,
75
- query,
76
- body,
77
- });
46
+ b.m("DELETE").h(headers).q(query).b(body);
47
+ return b.build();
78
48
  };
79
49
  export const se_CancelMLModelTransformJobCommand = async (input, context) => {
80
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
50
+ const b = rb(input, context);
81
51
  const headers = {};
82
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform/{id}";
83
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
52
+ b.bp("/ml/modeltransform/{id}");
53
+ b.p("id", () => input.id, "{id}", false);
84
54
  const query = map({
85
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
86
- clean: [() => input.clean !== void 0, () => input.clean.toString()],
55
+ [_nIRA]: [, input[_nIRA]],
56
+ [_c]: [() => input.clean !== void 0, () => input[_c].toString()],
87
57
  });
88
58
  let body;
89
- return new __HttpRequest({
90
- protocol,
91
- hostname,
92
- port,
93
- method: "DELETE",
94
- headers,
95
- path: resolvedPath,
96
- query,
97
- body,
98
- });
59
+ b.m("DELETE").h(headers).q(query).b(body);
60
+ return b.build();
99
61
  };
100
62
  export const se_CancelOpenCypherQueryCommand = async (input, context) => {
101
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
63
+ const b = rb(input, context);
102
64
  const headers = {};
103
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status/{queryId}";
104
- resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
65
+ b.bp("/opencypher/status/{queryId}");
66
+ b.p("queryId", () => input.queryId, "{queryId}", false);
105
67
  const query = map({
106
- silent: [() => input.silent !== void 0, () => input.silent.toString()],
68
+ [_s]: [() => input.silent !== void 0, () => input[_s].toString()],
107
69
  });
108
70
  let body;
109
- return new __HttpRequest({
110
- protocol,
111
- hostname,
112
- port,
113
- method: "DELETE",
114
- headers,
115
- path: resolvedPath,
116
- query,
117
- body,
118
- });
71
+ b.m("DELETE").h(headers).q(query).b(body);
72
+ return b.build();
119
73
  };
120
74
  export const se_CreateMLEndpointCommand = async (input, context) => {
121
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
75
+ const b = rb(input, context);
122
76
  const headers = {
123
77
  "content-type": "application/json",
124
78
  };
125
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints";
79
+ b.bp("/ml/endpoints");
126
80
  let body;
127
81
  body = JSON.stringify(take(input, {
128
82
  id: [],
@@ -135,120 +89,77 @@ export const se_CreateMLEndpointCommand = async (input, context) => {
135
89
  update: [],
136
90
  volumeEncryptionKMSKey: [],
137
91
  }));
138
- return new __HttpRequest({
139
- protocol,
140
- hostname,
141
- port,
142
- method: "POST",
143
- headers,
144
- path: resolvedPath,
145
- body,
146
- });
92
+ b.m("POST").h(headers).b(body);
93
+ return b.build();
147
94
  };
148
95
  export const se_DeleteMLEndpointCommand = async (input, context) => {
149
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
96
+ const b = rb(input, context);
150
97
  const headers = {};
151
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints/{id}";
152
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
98
+ b.bp("/ml/endpoints/{id}");
99
+ b.p("id", () => input.id, "{id}", false);
153
100
  const query = map({
154
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
155
- clean: [() => input.clean !== void 0, () => input.clean.toString()],
101
+ [_nIRA]: [, input[_nIRA]],
102
+ [_c]: [() => input.clean !== void 0, () => input[_c].toString()],
156
103
  });
157
104
  let body;
158
- return new __HttpRequest({
159
- protocol,
160
- hostname,
161
- port,
162
- method: "DELETE",
163
- headers,
164
- path: resolvedPath,
165
- query,
166
- body,
167
- });
105
+ b.m("DELETE").h(headers).q(query).b(body);
106
+ return b.build();
168
107
  };
169
108
  export const se_DeletePropertygraphStatisticsCommand = async (input, context) => {
170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
109
+ const b = rb(input, context);
171
110
  const headers = {
172
111
  "content-type": "application/json",
173
112
  };
174
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
113
+ b.bp("/propertygraph/statistics");
175
114
  let body;
176
115
  body = "";
177
- return new __HttpRequest({
178
- protocol,
179
- hostname,
180
- port,
181
- method: "DELETE",
182
- headers,
183
- path: resolvedPath,
184
- body,
185
- });
116
+ b.m("DELETE").h(headers).b(body);
117
+ return b.build();
186
118
  };
187
119
  export const se_DeleteSparqlStatisticsCommand = async (input, context) => {
188
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
120
+ const b = rb(input, context);
189
121
  const headers = {
190
122
  "content-type": "application/json",
191
123
  };
192
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
124
+ b.bp("/sparql/statistics");
193
125
  let body;
194
126
  body = "";
195
- return new __HttpRequest({
196
- protocol,
197
- hostname,
198
- port,
199
- method: "DELETE",
200
- headers,
201
- path: resolvedPath,
202
- body,
203
- });
127
+ b.m("DELETE").h(headers).b(body);
128
+ return b.build();
204
129
  };
205
130
  export const se_ExecuteFastResetCommand = async (input, context) => {
206
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
131
+ const b = rb(input, context);
207
132
  const headers = {
208
133
  "content-type": "application/json",
209
134
  };
210
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/system";
135
+ b.bp("/system");
211
136
  let body;
212
137
  body = JSON.stringify(take(input, {
213
138
  action: [],
214
139
  token: [],
215
140
  }));
216
- return new __HttpRequest({
217
- protocol,
218
- hostname,
219
- port,
220
- method: "POST",
221
- headers,
222
- path: resolvedPath,
223
- body,
224
- });
141
+ b.m("POST").h(headers).b(body);
142
+ return b.build();
225
143
  };
226
144
  export const se_ExecuteGremlinExplainQueryCommand = async (input, context) => {
227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
145
+ const b = rb(input, context);
228
146
  const headers = {
229
147
  "content-type": "application/json",
230
148
  };
231
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/explain";
149
+ b.bp("/gremlin/explain");
232
150
  let body;
233
151
  body = JSON.stringify(take(input, {
234
152
  gremlin: [, , `gremlinQuery`],
235
153
  }));
236
- return new __HttpRequest({
237
- protocol,
238
- hostname,
239
- port,
240
- method: "POST",
241
- headers,
242
- path: resolvedPath,
243
- body,
244
- });
154
+ b.m("POST").h(headers).b(body);
155
+ return b.build();
245
156
  };
246
157
  export const se_ExecuteGremlinProfileQueryCommand = async (input, context) => {
247
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
158
+ const b = rb(input, context);
248
159
  const headers = {
249
160
  "content-type": "application/json",
250
161
  };
251
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/profile";
162
+ b.bp("/gremlin/profile");
252
163
  let body;
253
164
  body = JSON.stringify(take(input, {
254
165
  "profile.chop": [, , `chop`],
@@ -257,539 +168,334 @@ export const se_ExecuteGremlinProfileQueryCommand = async (input, context) => {
257
168
  "profile.results": [, , `results`],
258
169
  "profile.serializer": [, , `serializer`],
259
170
  }));
260
- return new __HttpRequest({
261
- protocol,
262
- hostname,
263
- port,
264
- method: "POST",
265
- headers,
266
- path: resolvedPath,
267
- body,
268
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
269
173
  };
270
174
  export const se_ExecuteGremlinQueryCommand = async (input, context) => {
271
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
272
176
  const headers = map({}, isSerializableHeaderValue, {
273
177
  "content-type": "application/json",
274
- accept: input.serializer,
178
+ [_a]: input[_se],
275
179
  });
276
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin";
180
+ b.bp("/gremlin");
277
181
  let body;
278
182
  body = JSON.stringify(take(input, {
279
183
  gremlin: [, , `gremlinQuery`],
280
184
  }));
281
- return new __HttpRequest({
282
- protocol,
283
- hostname,
284
- port,
285
- method: "POST",
286
- headers,
287
- path: resolvedPath,
288
- body,
289
- });
185
+ b.m("POST").h(headers).b(body);
186
+ return b.build();
290
187
  };
291
188
  export const se_ExecuteOpenCypherExplainQueryCommand = async (input, context) => {
292
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = rb(input, context);
293
190
  const headers = {
294
191
  "content-type": "application/json",
295
192
  };
296
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/explain";
193
+ b.bp("/opencypher/explain");
297
194
  let body;
298
195
  body = JSON.stringify(take(input, {
299
196
  explain: [, , `explainMode`],
300
197
  query: [, , `openCypherQuery`],
301
198
  parameters: [],
302
199
  }));
303
- return new __HttpRequest({
304
- protocol,
305
- hostname,
306
- port,
307
- method: "POST",
308
- headers,
309
- path: resolvedPath,
310
- body,
311
- });
200
+ b.m("POST").h(headers).b(body);
201
+ return b.build();
312
202
  };
313
203
  export const se_ExecuteOpenCypherQueryCommand = async (input, context) => {
314
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
204
+ const b = rb(input, context);
315
205
  const headers = {
316
206
  "content-type": "application/json",
317
207
  };
318
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher";
208
+ b.bp("/opencypher");
319
209
  let body;
320
210
  body = JSON.stringify(take(input, {
321
211
  query: [, , `openCypherQuery`],
322
212
  parameters: [],
323
213
  }));
324
- return new __HttpRequest({
325
- protocol,
326
- hostname,
327
- port,
328
- method: "POST",
329
- headers,
330
- path: resolvedPath,
331
- body,
332
- });
214
+ b.m("POST").h(headers).b(body);
215
+ return b.build();
333
216
  };
334
217
  export const se_GetEngineStatusCommand = async (input, context) => {
335
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
218
+ const b = rb(input, context);
336
219
  const headers = {
337
220
  "content-type": "application/json",
338
221
  };
339
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/status";
222
+ b.bp("/status");
340
223
  let body;
341
224
  body = "";
342
- return new __HttpRequest({
343
- protocol,
344
- hostname,
345
- port,
346
- method: "GET",
347
- headers,
348
- path: resolvedPath,
349
- body,
350
- });
225
+ b.m("GET").h(headers).b(body);
226
+ return b.build();
351
227
  };
352
228
  export const se_GetGremlinQueryStatusCommand = async (input, context) => {
353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
229
+ const b = rb(input, context);
354
230
  const headers = {};
355
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status/{queryId}";
356
- resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
231
+ b.bp("/gremlin/status/{queryId}");
232
+ b.p("queryId", () => input.queryId, "{queryId}", false);
357
233
  let body;
358
- return new __HttpRequest({
359
- protocol,
360
- hostname,
361
- port,
362
- method: "GET",
363
- headers,
364
- path: resolvedPath,
365
- body,
366
- });
234
+ b.m("GET").h(headers).b(body);
235
+ return b.build();
367
236
  };
368
237
  export const se_GetLoaderJobStatusCommand = async (input, context) => {
369
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
238
+ const b = rb(input, context);
370
239
  const headers = {};
371
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader/{loadId}";
372
- resolvedPath = __resolvedPath(resolvedPath, input, "loadId", () => input.loadId, "{loadId}", false);
240
+ b.bp("/loader/{loadId}");
241
+ b.p("loadId", () => input.loadId, "{loadId}", false);
373
242
  const query = map({
374
- details: [() => input.details !== void 0, () => input.details.toString()],
375
- errors: [() => input.errors !== void 0, () => input.errors.toString()],
376
- page: [() => input.page !== void 0, () => input.page.toString()],
377
- errorsPerPage: [() => input.errorsPerPage !== void 0, () => input.errorsPerPage.toString()],
243
+ [_d]: [() => input.details !== void 0, () => input[_d].toString()],
244
+ [_e]: [() => input.errors !== void 0, () => input[_e].toString()],
245
+ [_p]: [() => input.page !== void 0, () => input[_p].toString()],
246
+ [_ePP]: [() => input.errorsPerPage !== void 0, () => input[_ePP].toString()],
378
247
  });
379
248
  let body;
380
- return new __HttpRequest({
381
- protocol,
382
- hostname,
383
- port,
384
- method: "GET",
385
- headers,
386
- path: resolvedPath,
387
- query,
388
- body,
389
- });
249
+ b.m("GET").h(headers).q(query).b(body);
250
+ return b.build();
390
251
  };
391
252
  export const se_GetMLDataProcessingJobCommand = async (input, context) => {
392
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
253
+ const b = rb(input, context);
393
254
  const headers = {};
394
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing/{id}";
395
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
255
+ b.bp("/ml/dataprocessing/{id}");
256
+ b.p("id", () => input.id, "{id}", false);
396
257
  const query = map({
397
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
258
+ [_nIRA]: [, input[_nIRA]],
398
259
  });
399
260
  let body;
400
- return new __HttpRequest({
401
- protocol,
402
- hostname,
403
- port,
404
- method: "GET",
405
- headers,
406
- path: resolvedPath,
407
- query,
408
- body,
409
- });
261
+ b.m("GET").h(headers).q(query).b(body);
262
+ return b.build();
410
263
  };
411
264
  export const se_GetMLEndpointCommand = async (input, context) => {
412
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
413
266
  const headers = {};
414
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints/{id}";
415
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
267
+ b.bp("/ml/endpoints/{id}");
268
+ b.p("id", () => input.id, "{id}", false);
416
269
  const query = map({
417
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
270
+ [_nIRA]: [, input[_nIRA]],
418
271
  });
419
272
  let body;
420
- return new __HttpRequest({
421
- protocol,
422
- hostname,
423
- port,
424
- method: "GET",
425
- headers,
426
- path: resolvedPath,
427
- query,
428
- body,
429
- });
273
+ b.m("GET").h(headers).q(query).b(body);
274
+ return b.build();
430
275
  };
431
276
  export const se_GetMLModelTrainingJobCommand = async (input, context) => {
432
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
277
+ const b = rb(input, context);
433
278
  const headers = {};
434
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining/{id}";
435
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
279
+ b.bp("/ml/modeltraining/{id}");
280
+ b.p("id", () => input.id, "{id}", false);
436
281
  const query = map({
437
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
282
+ [_nIRA]: [, input[_nIRA]],
438
283
  });
439
284
  let body;
440
- return new __HttpRequest({
441
- protocol,
442
- hostname,
443
- port,
444
- method: "GET",
445
- headers,
446
- path: resolvedPath,
447
- query,
448
- body,
449
- });
285
+ b.m("GET").h(headers).q(query).b(body);
286
+ return b.build();
450
287
  };
451
288
  export const se_GetMLModelTransformJobCommand = async (input, context) => {
452
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
289
+ const b = rb(input, context);
453
290
  const headers = {};
454
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform/{id}";
455
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
291
+ b.bp("/ml/modeltransform/{id}");
292
+ b.p("id", () => input.id, "{id}", false);
456
293
  const query = map({
457
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
294
+ [_nIRA]: [, input[_nIRA]],
458
295
  });
459
296
  let body;
460
- return new __HttpRequest({
461
- protocol,
462
- hostname,
463
- port,
464
- method: "GET",
465
- headers,
466
- path: resolvedPath,
467
- query,
468
- body,
469
- });
297
+ b.m("GET").h(headers).q(query).b(body);
298
+ return b.build();
470
299
  };
471
300
  export const se_GetOpenCypherQueryStatusCommand = async (input, context) => {
472
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
301
+ const b = rb(input, context);
473
302
  const headers = {};
474
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status/{queryId}";
475
- resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
303
+ b.bp("/opencypher/status/{queryId}");
304
+ b.p("queryId", () => input.queryId, "{queryId}", false);
476
305
  let body;
477
- return new __HttpRequest({
478
- protocol,
479
- hostname,
480
- port,
481
- method: "GET",
482
- headers,
483
- path: resolvedPath,
484
- body,
485
- });
306
+ b.m("GET").h(headers).b(body);
307
+ return b.build();
486
308
  };
487
309
  export const se_GetPropertygraphStatisticsCommand = async (input, context) => {
488
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
310
+ const b = rb(input, context);
489
311
  const headers = {
490
312
  "content-type": "application/json",
491
313
  };
492
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
314
+ b.bp("/propertygraph/statistics");
493
315
  let body;
494
316
  body = "";
495
- return new __HttpRequest({
496
- protocol,
497
- hostname,
498
- port,
499
- method: "GET",
500
- headers,
501
- path: resolvedPath,
502
- body,
503
- });
317
+ b.m("GET").h(headers).b(body);
318
+ return b.build();
504
319
  };
505
320
  export const se_GetPropertygraphStreamCommand = async (input, context) => {
506
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = rb(input, context);
507
322
  const headers = map({}, isSerializableHeaderValue, {
508
- "accept-encoding": input.encoding,
323
+ [_ae]: input[_en],
509
324
  });
510
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/stream";
325
+ b.bp("/propertygraph/stream");
511
326
  const query = map({
512
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
513
- iteratorType: [, input.iteratorType],
514
- commitNum: [() => input.commitNum !== void 0, () => input.commitNum.toString()],
515
- opNum: [() => input.opNum !== void 0, () => input.opNum.toString()],
327
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
328
+ [_iT]: [, input[_iT]],
329
+ [_cN]: [() => input.commitNum !== void 0, () => input[_cN].toString()],
330
+ [_oN]: [() => input.opNum !== void 0, () => input[_oN].toString()],
516
331
  });
517
332
  let body;
518
- return new __HttpRequest({
519
- protocol,
520
- hostname,
521
- port,
522
- method: "GET",
523
- headers,
524
- path: resolvedPath,
525
- query,
526
- body,
527
- });
333
+ b.m("GET").h(headers).q(query).b(body);
334
+ return b.build();
528
335
  };
529
336
  export const se_GetPropertygraphSummaryCommand = async (input, context) => {
530
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
337
+ const b = rb(input, context);
531
338
  const headers = {};
532
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics/summary";
339
+ b.bp("/propertygraph/statistics/summary");
533
340
  const query = map({
534
- mode: [, input.mode],
341
+ [_m]: [, input[_m]],
535
342
  });
536
343
  let body;
537
- return new __HttpRequest({
538
- protocol,
539
- hostname,
540
- port,
541
- method: "GET",
542
- headers,
543
- path: resolvedPath,
544
- query,
545
- body,
546
- });
344
+ b.m("GET").h(headers).q(query).b(body);
345
+ return b.build();
547
346
  };
548
347
  export const se_GetRDFGraphSummaryCommand = async (input, context) => {
549
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
348
+ const b = rb(input, context);
550
349
  const headers = {};
551
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rdf/statistics/summary";
350
+ b.bp("/rdf/statistics/summary");
552
351
  const query = map({
553
- mode: [, input.mode],
352
+ [_m]: [, input[_m]],
554
353
  });
555
354
  let body;
556
- return new __HttpRequest({
557
- protocol,
558
- hostname,
559
- port,
560
- method: "GET",
561
- headers,
562
- path: resolvedPath,
563
- query,
564
- body,
565
- });
355
+ b.m("GET").h(headers).q(query).b(body);
356
+ return b.build();
566
357
  };
567
358
  export const se_GetSparqlStatisticsCommand = async (input, context) => {
568
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
359
+ const b = rb(input, context);
569
360
  const headers = {
570
361
  "content-type": "application/json",
571
362
  };
572
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
363
+ b.bp("/sparql/statistics");
573
364
  let body;
574
365
  body = "";
575
- return new __HttpRequest({
576
- protocol,
577
- hostname,
578
- port,
579
- method: "GET",
580
- headers,
581
- path: resolvedPath,
582
- body,
583
- });
366
+ b.m("GET").h(headers).b(body);
367
+ return b.build();
584
368
  };
585
369
  export const se_GetSparqlStreamCommand = async (input, context) => {
586
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
370
+ const b = rb(input, context);
587
371
  const headers = map({}, isSerializableHeaderValue, {
588
- "accept-encoding": input.encoding,
372
+ [_ae]: input[_en],
589
373
  });
590
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/stream";
374
+ b.bp("/sparql/stream");
591
375
  const query = map({
592
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
593
- iteratorType: [, input.iteratorType],
594
- commitNum: [() => input.commitNum !== void 0, () => input.commitNum.toString()],
595
- opNum: [() => input.opNum !== void 0, () => input.opNum.toString()],
376
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
377
+ [_iT]: [, input[_iT]],
378
+ [_cN]: [() => input.commitNum !== void 0, () => input[_cN].toString()],
379
+ [_oN]: [() => input.opNum !== void 0, () => input[_oN].toString()],
596
380
  });
597
381
  let body;
598
- return new __HttpRequest({
599
- protocol,
600
- hostname,
601
- port,
602
- method: "GET",
603
- headers,
604
- path: resolvedPath,
605
- query,
606
- body,
607
- });
382
+ b.m("GET").h(headers).q(query).b(body);
383
+ return b.build();
608
384
  };
609
385
  export const se_ListGremlinQueriesCommand = async (input, context) => {
610
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
386
+ const b = rb(input, context);
611
387
  const headers = {};
612
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status";
388
+ b.bp("/gremlin/status");
613
389
  const query = map({
614
- includeWaiting: [() => input.includeWaiting !== void 0, () => input.includeWaiting.toString()],
390
+ [_iW]: [() => input.includeWaiting !== void 0, () => input[_iW].toString()],
615
391
  });
616
392
  let body;
617
- return new __HttpRequest({
618
- protocol,
619
- hostname,
620
- port,
621
- method: "GET",
622
- headers,
623
- path: resolvedPath,
624
- query,
625
- body,
626
- });
393
+ b.m("GET").h(headers).q(query).b(body);
394
+ return b.build();
627
395
  };
628
396
  export const se_ListLoaderJobsCommand = async (input, context) => {
629
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = rb(input, context);
630
398
  const headers = {};
631
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader";
399
+ b.bp("/loader");
632
400
  const query = map({
633
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
634
- includeQueuedLoads: [() => input.includeQueuedLoads !== void 0, () => input.includeQueuedLoads.toString()],
401
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
402
+ [_iQL]: [() => input.includeQueuedLoads !== void 0, () => input[_iQL].toString()],
635
403
  });
636
404
  let body;
637
- return new __HttpRequest({
638
- protocol,
639
- hostname,
640
- port,
641
- method: "GET",
642
- headers,
643
- path: resolvedPath,
644
- query,
645
- body,
646
- });
405
+ b.m("GET").h(headers).q(query).b(body);
406
+ return b.build();
647
407
  };
648
408
  export const se_ListMLDataProcessingJobsCommand = async (input, context) => {
649
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
409
+ const b = rb(input, context);
650
410
  const headers = {};
651
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing";
411
+ b.bp("/ml/dataprocessing");
652
412
  const query = map({
653
- maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
654
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
413
+ [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],
414
+ [_nIRA]: [, input[_nIRA]],
655
415
  });
656
416
  let body;
657
- return new __HttpRequest({
658
- protocol,
659
- hostname,
660
- port,
661
- method: "GET",
662
- headers,
663
- path: resolvedPath,
664
- query,
665
- body,
666
- });
417
+ b.m("GET").h(headers).q(query).b(body);
418
+ return b.build();
667
419
  };
668
420
  export const se_ListMLEndpointsCommand = async (input, context) => {
669
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
421
+ const b = rb(input, context);
670
422
  const headers = {};
671
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints";
423
+ b.bp("/ml/endpoints");
672
424
  const query = map({
673
- maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
674
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
425
+ [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],
426
+ [_nIRA]: [, input[_nIRA]],
675
427
  });
676
428
  let body;
677
- return new __HttpRequest({
678
- protocol,
679
- hostname,
680
- port,
681
- method: "GET",
682
- headers,
683
- path: resolvedPath,
684
- query,
685
- body,
686
- });
429
+ b.m("GET").h(headers).q(query).b(body);
430
+ return b.build();
687
431
  };
688
432
  export const se_ListMLModelTrainingJobsCommand = async (input, context) => {
689
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
690
434
  const headers = {};
691
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining";
435
+ b.bp("/ml/modeltraining");
692
436
  const query = map({
693
- maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
694
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
437
+ [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],
438
+ [_nIRA]: [, input[_nIRA]],
695
439
  });
696
440
  let body;
697
- return new __HttpRequest({
698
- protocol,
699
- hostname,
700
- port,
701
- method: "GET",
702
- headers,
703
- path: resolvedPath,
704
- query,
705
- body,
706
- });
441
+ b.m("GET").h(headers).q(query).b(body);
442
+ return b.build();
707
443
  };
708
444
  export const se_ListMLModelTransformJobsCommand = async (input, context) => {
709
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
445
+ const b = rb(input, context);
710
446
  const headers = {};
711
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform";
447
+ b.bp("/ml/modeltransform");
712
448
  const query = map({
713
- maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
714
- neptuneIamRoleArn: [, input.neptuneIamRoleArn],
449
+ [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],
450
+ [_nIRA]: [, input[_nIRA]],
715
451
  });
716
452
  let body;
717
- return new __HttpRequest({
718
- protocol,
719
- hostname,
720
- port,
721
- method: "GET",
722
- headers,
723
- path: resolvedPath,
724
- query,
725
- body,
726
- });
453
+ b.m("GET").h(headers).q(query).b(body);
454
+ return b.build();
727
455
  };
728
456
  export const se_ListOpenCypherQueriesCommand = async (input, context) => {
729
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
457
+ const b = rb(input, context);
730
458
  const headers = {};
731
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status";
459
+ b.bp("/opencypher/status");
732
460
  const query = map({
733
- includeWaiting: [() => input.includeWaiting !== void 0, () => input.includeWaiting.toString()],
461
+ [_iW]: [() => input.includeWaiting !== void 0, () => input[_iW].toString()],
734
462
  });
735
463
  let body;
736
- return new __HttpRequest({
737
- protocol,
738
- hostname,
739
- port,
740
- method: "GET",
741
- headers,
742
- path: resolvedPath,
743
- query,
744
- body,
745
- });
464
+ b.m("GET").h(headers).q(query).b(body);
465
+ return b.build();
746
466
  };
747
467
  export const se_ManagePropertygraphStatisticsCommand = async (input, context) => {
748
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
468
+ const b = rb(input, context);
749
469
  const headers = {
750
470
  "content-type": "application/json",
751
471
  };
752
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
472
+ b.bp("/propertygraph/statistics");
753
473
  let body;
754
474
  body = JSON.stringify(take(input, {
755
475
  mode: [],
756
476
  }));
757
- return new __HttpRequest({
758
- protocol,
759
- hostname,
760
- port,
761
- method: "POST",
762
- headers,
763
- path: resolvedPath,
764
- body,
765
- });
477
+ b.m("POST").h(headers).b(body);
478
+ return b.build();
766
479
  };
767
480
  export const se_ManageSparqlStatisticsCommand = async (input, context) => {
768
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
481
+ const b = rb(input, context);
769
482
  const headers = {
770
483
  "content-type": "application/json",
771
484
  };
772
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
485
+ b.bp("/sparql/statistics");
773
486
  let body;
774
487
  body = JSON.stringify(take(input, {
775
488
  mode: [],
776
489
  }));
777
- return new __HttpRequest({
778
- protocol,
779
- hostname,
780
- port,
781
- method: "POST",
782
- headers,
783
- path: resolvedPath,
784
- body,
785
- });
490
+ b.m("POST").h(headers).b(body);
491
+ return b.build();
786
492
  };
787
493
  export const se_StartLoaderJobCommand = async (input, context) => {
788
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
494
+ const b = rb(input, context);
789
495
  const headers = {
790
496
  "content-type": "application/json",
791
497
  };
792
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader";
498
+ b.bp("/loader");
793
499
  let body;
794
500
  body = JSON.stringify(take(input, {
795
501
  dependencies: (_) => _json(_),
@@ -805,22 +511,15 @@ export const se_StartLoaderJobCommand = async (input, context) => {
805
511
  updateSingleCardinalityProperties: [],
806
512
  userProvidedEdgeIds: [],
807
513
  }));
808
- return new __HttpRequest({
809
- protocol,
810
- hostname,
811
- port,
812
- method: "POST",
813
- headers,
814
- path: resolvedPath,
815
- body,
816
- });
514
+ b.m("POST").h(headers).b(body);
515
+ return b.build();
817
516
  };
818
517
  export const se_StartMLDataProcessingJobCommand = async (input, context) => {
819
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
518
+ const b = rb(input, context);
820
519
  const headers = {
821
520
  "content-type": "application/json",
822
521
  };
823
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing";
522
+ b.bp("/ml/dataprocessing");
824
523
  let body;
825
524
  body = JSON.stringify(take(input, {
826
525
  configFileName: [],
@@ -839,22 +538,15 @@ export const se_StartMLDataProcessingJobCommand = async (input, context) => {
839
538
  subnets: (_) => _json(_),
840
539
  volumeEncryptionKMSKey: [],
841
540
  }));
842
- return new __HttpRequest({
843
- protocol,
844
- hostname,
845
- port,
846
- method: "POST",
847
- headers,
848
- path: resolvedPath,
849
- body,
850
- });
541
+ b.m("POST").h(headers).b(body);
542
+ return b.build();
851
543
  };
852
544
  export const se_StartMLModelTrainingJobCommand = async (input, context) => {
853
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
545
+ const b = rb(input, context);
854
546
  const headers = {
855
547
  "content-type": "application/json",
856
548
  };
857
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining";
549
+ b.bp("/ml/modeltraining");
858
550
  let body;
859
551
  body = JSON.stringify(take(input, {
860
552
  baseProcessingInstanceType: [],
@@ -876,22 +568,15 @@ export const se_StartMLModelTrainingJobCommand = async (input, context) => {
876
568
  trainingTimeOutInSeconds: [],
877
569
  volumeEncryptionKMSKey: [],
878
570
  }));
879
- return new __HttpRequest({
880
- protocol,
881
- hostname,
882
- port,
883
- method: "POST",
884
- headers,
885
- path: resolvedPath,
886
- body,
887
- });
571
+ b.m("POST").h(headers).b(body);
572
+ return b.build();
888
573
  };
889
574
  export const se_StartMLModelTransformJobCommand = async (input, context) => {
890
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
575
+ const b = rb(input, context);
891
576
  const headers = {
892
577
  "content-type": "application/json",
893
578
  };
894
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform";
579
+ b.bp("/ml/modeltransform");
895
580
  let body;
896
581
  body = JSON.stringify(take(input, {
897
582
  baseProcessingInstanceType: [],
@@ -909,15 +594,8 @@ export const se_StartMLModelTransformJobCommand = async (input, context) => {
909
594
  trainingJobName: [],
910
595
  volumeEncryptionKMSKey: [],
911
596
  }));
912
- return new __HttpRequest({
913
- protocol,
914
- hostname,
915
- port,
916
- method: "POST",
917
- headers,
918
- path: resolvedPath,
919
- body,
920
- });
597
+ b.m("POST").h(headers).b(body);
598
+ return b.build();
921
599
  };
922
600
  export const de_CancelGremlinQueryCommand = async (output, context) => {
923
601
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4639,6 +4317,25 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
4639
4317
  value !== "" &&
4640
4318
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
4641
4319
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
4320
+ const _a = "accept";
4321
+ const _ae = "accept-encoding";
4322
+ const _c = "clean";
4323
+ const _cN = "commitNum";
4324
+ const _d = "details";
4325
+ const _e = "errors";
4326
+ const _ePP = "errorsPerPage";
4327
+ const _en = "encoding";
4328
+ const _iQL = "includeQueuedLoads";
4329
+ const _iT = "iteratorType";
4330
+ const _iW = "includeWaiting";
4331
+ const _l = "limit";
4332
+ const _m = "mode";
4333
+ const _mI = "maxItems";
4334
+ const _nIRA = "neptuneIamRoleArn";
4335
+ const _oN = "opNum";
4336
+ const _p = "page";
4337
+ const _s = "silent";
4338
+ const _se = "serializer";
4642
4339
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
4643
4340
  if (encoded.length) {
4644
4341
  return JSON.parse(encoded);