@aws-sdk/client-xray 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 +121 -331
  2. package/dist-es/protocols/Aws_restJson1.js +121 -331
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,35 +1,28 @@
1
1
  import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
2
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
+ import { requestBuilder as rb } from "@smithy/core";
3
3
  import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
4
4
  import { InvalidPolicyRevisionIdException, InvalidRequestException, LockoutPreventionException, MalformedPolicyDocumentException, PolicyCountLimitExceededException, PolicySizeLimitExceededException, ResourceNotFoundException, RuleLimitExceededException, ThrottledException, TooManyTagsException, } from "../models/models_0";
5
5
  import { XRayServiceException as __BaseException } from "../models/XRayServiceException";
6
6
  export const se_BatchGetTracesCommand = 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
9
  "content-type": "application/json",
10
10
  };
11
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/Traces";
11
+ b.bp("/Traces");
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  NextToken: [],
15
15
  TraceIds: (_) => _json(_),
16
16
  }));
17
- return new __HttpRequest({
18
- protocol,
19
- hostname,
20
- port,
21
- method: "POST",
22
- headers,
23
- path: resolvedPath,
24
- body,
25
- });
17
+ b.m("POST").h(headers).b(body);
18
+ return b.build();
26
19
  };
27
20
  export const se_CreateGroupCommand = async (input, context) => {
28
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
21
+ const b = rb(input, context);
29
22
  const headers = {
30
23
  "content-type": "application/json",
31
24
  };
32
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateGroup";
25
+ b.bp("/CreateGroup");
33
26
  let body;
34
27
  body = JSON.stringify(take(input, {
35
28
  FilterExpression: [],
@@ -37,207 +30,137 @@ export const se_CreateGroupCommand = async (input, context) => {
37
30
  InsightsConfiguration: (_) => _json(_),
38
31
  Tags: (_) => _json(_),
39
32
  }));
40
- return new __HttpRequest({
41
- protocol,
42
- hostname,
43
- port,
44
- method: "POST",
45
- headers,
46
- path: resolvedPath,
47
- body,
48
- });
33
+ b.m("POST").h(headers).b(body);
34
+ return b.build();
49
35
  };
50
36
  export const se_CreateSamplingRuleCommand = async (input, context) => {
51
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
37
+ const b = rb(input, context);
52
38
  const headers = {
53
39
  "content-type": "application/json",
54
40
  };
55
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateSamplingRule";
41
+ b.bp("/CreateSamplingRule");
56
42
  let body;
57
43
  body = JSON.stringify(take(input, {
58
44
  SamplingRule: (_) => se_SamplingRule(_, context),
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_DeleteGroupCommand = 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 || ""}` + "/DeleteGroup";
55
+ b.bp("/DeleteGroup");
77
56
  let body;
78
57
  body = JSON.stringify(take(input, {
79
58
  GroupARN: [],
80
59
  GroupName: [],
81
60
  }));
82
- return new __HttpRequest({
83
- protocol,
84
- hostname,
85
- port,
86
- method: "POST",
87
- headers,
88
- path: resolvedPath,
89
- body,
90
- });
61
+ b.m("POST").h(headers).b(body);
62
+ return b.build();
91
63
  };
92
64
  export const se_DeleteResourcePolicyCommand = async (input, context) => {
93
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
65
+ const b = rb(input, context);
94
66
  const headers = {
95
67
  "content-type": "application/json",
96
68
  };
97
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteResourcePolicy";
69
+ b.bp("/DeleteResourcePolicy");
98
70
  let body;
99
71
  body = JSON.stringify(take(input, {
100
72
  PolicyName: [],
101
73
  PolicyRevisionId: [],
102
74
  }));
103
- return new __HttpRequest({
104
- protocol,
105
- hostname,
106
- port,
107
- method: "POST",
108
- headers,
109
- path: resolvedPath,
110
- body,
111
- });
75
+ b.m("POST").h(headers).b(body);
76
+ return b.build();
112
77
  };
113
78
  export const se_DeleteSamplingRuleCommand = async (input, context) => {
114
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
79
+ const b = rb(input, context);
115
80
  const headers = {
116
81
  "content-type": "application/json",
117
82
  };
118
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteSamplingRule";
83
+ b.bp("/DeleteSamplingRule");
119
84
  let body;
120
85
  body = JSON.stringify(take(input, {
121
86
  RuleARN: [],
122
87
  RuleName: [],
123
88
  }));
124
- return new __HttpRequest({
125
- protocol,
126
- hostname,
127
- port,
128
- method: "POST",
129
- headers,
130
- path: resolvedPath,
131
- body,
132
- });
89
+ b.m("POST").h(headers).b(body);
90
+ return b.build();
133
91
  };
134
92
  export const se_GetEncryptionConfigCommand = async (input, context) => {
135
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
93
+ const b = rb(input, context);
136
94
  const headers = {
137
95
  "content-type": "application/json",
138
96
  };
139
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/EncryptionConfig";
97
+ b.bp("/EncryptionConfig");
140
98
  let body;
141
99
  body = "";
142
- return new __HttpRequest({
143
- protocol,
144
- hostname,
145
- port,
146
- method: "POST",
147
- headers,
148
- path: resolvedPath,
149
- body,
150
- });
100
+ b.m("POST").h(headers).b(body);
101
+ return b.build();
151
102
  };
152
103
  export const se_GetGroupCommand = async (input, context) => {
153
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
104
+ const b = rb(input, context);
154
105
  const headers = {
155
106
  "content-type": "application/json",
156
107
  };
157
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetGroup";
108
+ b.bp("/GetGroup");
158
109
  let body;
159
110
  body = JSON.stringify(take(input, {
160
111
  GroupARN: [],
161
112
  GroupName: [],
162
113
  }));
163
- return new __HttpRequest({
164
- protocol,
165
- hostname,
166
- port,
167
- method: "POST",
168
- headers,
169
- path: resolvedPath,
170
- body,
171
- });
114
+ b.m("POST").h(headers).b(body);
115
+ return b.build();
172
116
  };
173
117
  export const se_GetGroupsCommand = async (input, context) => {
174
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
118
+ const b = rb(input, context);
175
119
  const headers = {
176
120
  "content-type": "application/json",
177
121
  };
178
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/Groups";
122
+ b.bp("/Groups");
179
123
  let body;
180
124
  body = JSON.stringify(take(input, {
181
125
  NextToken: [],
182
126
  }));
183
- return new __HttpRequest({
184
- protocol,
185
- hostname,
186
- port,
187
- method: "POST",
188
- headers,
189
- path: resolvedPath,
190
- body,
191
- });
127
+ b.m("POST").h(headers).b(body);
128
+ return b.build();
192
129
  };
193
130
  export const se_GetInsightCommand = async (input, context) => {
194
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
131
+ const b = rb(input, context);
195
132
  const headers = {
196
133
  "content-type": "application/json",
197
134
  };
198
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/Insight";
135
+ b.bp("/Insight");
199
136
  let body;
200
137
  body = JSON.stringify(take(input, {
201
138
  InsightId: [],
202
139
  }));
203
- return new __HttpRequest({
204
- protocol,
205
- hostname,
206
- port,
207
- method: "POST",
208
- headers,
209
- path: resolvedPath,
210
- body,
211
- });
140
+ b.m("POST").h(headers).b(body);
141
+ return b.build();
212
142
  };
213
143
  export const se_GetInsightEventsCommand = async (input, context) => {
214
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
144
+ const b = rb(input, context);
215
145
  const headers = {
216
146
  "content-type": "application/json",
217
147
  };
218
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/InsightEvents";
148
+ b.bp("/InsightEvents");
219
149
  let body;
220
150
  body = JSON.stringify(take(input, {
221
151
  InsightId: [],
222
152
  MaxResults: [],
223
153
  NextToken: [],
224
154
  }));
225
- return new __HttpRequest({
226
- protocol,
227
- hostname,
228
- port,
229
- method: "POST",
230
- headers,
231
- path: resolvedPath,
232
- body,
233
- });
155
+ b.m("POST").h(headers).b(body);
156
+ return b.build();
234
157
  };
235
158
  export const se_GetInsightImpactGraphCommand = async (input, context) => {
236
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
237
160
  const headers = {
238
161
  "content-type": "application/json",
239
162
  };
240
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/InsightImpactGraph";
163
+ b.bp("/InsightImpactGraph");
241
164
  let body;
242
165
  body = JSON.stringify(take(input, {
243
166
  EndTime: (_) => Math.round(_.getTime() / 1000),
@@ -245,22 +168,15 @@ export const se_GetInsightImpactGraphCommand = async (input, context) => {
245
168
  NextToken: [],
246
169
  StartTime: (_) => Math.round(_.getTime() / 1000),
247
170
  }));
248
- return new __HttpRequest({
249
- protocol,
250
- hostname,
251
- port,
252
- method: "POST",
253
- headers,
254
- path: resolvedPath,
255
- body,
256
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
257
173
  };
258
174
  export const se_GetInsightSummariesCommand = async (input, context) => {
259
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
260
176
  const headers = {
261
177
  "content-type": "application/json",
262
178
  };
263
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/InsightSummaries";
179
+ b.bp("/InsightSummaries");
264
180
  let body;
265
181
  body = JSON.stringify(take(input, {
266
182
  EndTime: (_) => Math.round(_.getTime() / 1000),
@@ -271,82 +187,54 @@ export const se_GetInsightSummariesCommand = async (input, context) => {
271
187
  StartTime: (_) => Math.round(_.getTime() / 1000),
272
188
  States: (_) => _json(_),
273
189
  }));
274
- return new __HttpRequest({
275
- protocol,
276
- hostname,
277
- port,
278
- method: "POST",
279
- headers,
280
- path: resolvedPath,
281
- body,
282
- });
190
+ b.m("POST").h(headers).b(body);
191
+ return b.build();
283
192
  };
284
193
  export const se_GetSamplingRulesCommand = async (input, context) => {
285
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
194
+ const b = rb(input, context);
286
195
  const headers = {
287
196
  "content-type": "application/json",
288
197
  };
289
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetSamplingRules";
198
+ b.bp("/GetSamplingRules");
290
199
  let body;
291
200
  body = JSON.stringify(take(input, {
292
201
  NextToken: [],
293
202
  }));
294
- return new __HttpRequest({
295
- protocol,
296
- hostname,
297
- port,
298
- method: "POST",
299
- headers,
300
- path: resolvedPath,
301
- body,
302
- });
203
+ b.m("POST").h(headers).b(body);
204
+ return b.build();
303
205
  };
304
206
  export const se_GetSamplingStatisticSummariesCommand = async (input, context) => {
305
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
207
+ const b = rb(input, context);
306
208
  const headers = {
307
209
  "content-type": "application/json",
308
210
  };
309
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/SamplingStatisticSummaries";
211
+ b.bp("/SamplingStatisticSummaries");
310
212
  let body;
311
213
  body = JSON.stringify(take(input, {
312
214
  NextToken: [],
313
215
  }));
314
- return new __HttpRequest({
315
- protocol,
316
- hostname,
317
- port,
318
- method: "POST",
319
- headers,
320
- path: resolvedPath,
321
- body,
322
- });
216
+ b.m("POST").h(headers).b(body);
217
+ return b.build();
323
218
  };
324
219
  export const se_GetSamplingTargetsCommand = async (input, context) => {
325
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
220
+ const b = rb(input, context);
326
221
  const headers = {
327
222
  "content-type": "application/json",
328
223
  };
329
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/SamplingTargets";
224
+ b.bp("/SamplingTargets");
330
225
  let body;
331
226
  body = JSON.stringify(take(input, {
332
227
  SamplingStatisticsDocuments: (_) => se_SamplingStatisticsDocumentList(_, context),
333
228
  }));
334
- return new __HttpRequest({
335
- protocol,
336
- hostname,
337
- port,
338
- method: "POST",
339
- headers,
340
- path: resolvedPath,
341
- body,
342
- });
229
+ b.m("POST").h(headers).b(body);
230
+ return b.build();
343
231
  };
344
232
  export const se_GetServiceGraphCommand = async (input, context) => {
345
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
233
+ const b = rb(input, context);
346
234
  const headers = {
347
235
  "content-type": "application/json",
348
236
  };
349
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ServiceGraph";
237
+ b.bp("/ServiceGraph");
350
238
  let body;
351
239
  body = JSON.stringify(take(input, {
352
240
  EndTime: (_) => Math.round(_.getTime() / 1000),
@@ -355,22 +243,15 @@ export const se_GetServiceGraphCommand = async (input, context) => {
355
243
  NextToken: [],
356
244
  StartTime: (_) => Math.round(_.getTime() / 1000),
357
245
  }));
358
- return new __HttpRequest({
359
- protocol,
360
- hostname,
361
- port,
362
- method: "POST",
363
- headers,
364
- path: resolvedPath,
365
- body,
366
- });
246
+ b.m("POST").h(headers).b(body);
247
+ return b.build();
367
248
  };
368
249
  export const se_GetTimeSeriesServiceStatisticsCommand = async (input, context) => {
369
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
250
+ const b = rb(input, context);
370
251
  const headers = {
371
252
  "content-type": "application/json",
372
253
  };
373
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TimeSeriesServiceStatistics";
254
+ b.bp("/TimeSeriesServiceStatistics");
374
255
  let body;
375
256
  body = JSON.stringify(take(input, {
376
257
  EndTime: (_) => Math.round(_.getTime() / 1000),
@@ -382,43 +263,29 @@ export const se_GetTimeSeriesServiceStatisticsCommand = async (input, context) =
382
263
  Period: [],
383
264
  StartTime: (_) => Math.round(_.getTime() / 1000),
384
265
  }));
385
- return new __HttpRequest({
386
- protocol,
387
- hostname,
388
- port,
389
- method: "POST",
390
- headers,
391
- path: resolvedPath,
392
- body,
393
- });
266
+ b.m("POST").h(headers).b(body);
267
+ return b.build();
394
268
  };
395
269
  export const se_GetTraceGraphCommand = async (input, context) => {
396
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
270
+ const b = rb(input, context);
397
271
  const headers = {
398
272
  "content-type": "application/json",
399
273
  };
400
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TraceGraph";
274
+ b.bp("/TraceGraph");
401
275
  let body;
402
276
  body = JSON.stringify(take(input, {
403
277
  NextToken: [],
404
278
  TraceIds: (_) => _json(_),
405
279
  }));
406
- return new __HttpRequest({
407
- protocol,
408
- hostname,
409
- port,
410
- method: "POST",
411
- headers,
412
- path: resolvedPath,
413
- body,
414
- });
280
+ b.m("POST").h(headers).b(body);
281
+ return b.build();
415
282
  };
416
283
  export const se_GetTraceSummariesCommand = async (input, context) => {
417
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
284
+ const b = rb(input, context);
418
285
  const headers = {
419
286
  "content-type": "application/json",
420
287
  };
421
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TraceSummaries";
288
+ b.bp("/TraceSummaries");
422
289
  let body;
423
290
  body = JSON.stringify(take(input, {
424
291
  EndTime: (_) => Math.round(_.getTime() / 1000),
@@ -429,84 +296,56 @@ export const se_GetTraceSummariesCommand = async (input, context) => {
429
296
  StartTime: (_) => Math.round(_.getTime() / 1000),
430
297
  TimeRangeType: [],
431
298
  }));
432
- return new __HttpRequest({
433
- protocol,
434
- hostname,
435
- port,
436
- method: "POST",
437
- headers,
438
- path: resolvedPath,
439
- body,
440
- });
299
+ b.m("POST").h(headers).b(body);
300
+ return b.build();
441
301
  };
442
302
  export const se_ListResourcePoliciesCommand = async (input, context) => {
443
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
303
+ const b = rb(input, context);
444
304
  const headers = {
445
305
  "content-type": "application/json",
446
306
  };
447
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListResourcePolicies";
307
+ b.bp("/ListResourcePolicies");
448
308
  let body;
449
309
  body = JSON.stringify(take(input, {
450
310
  NextToken: [],
451
311
  }));
452
- return new __HttpRequest({
453
- protocol,
454
- hostname,
455
- port,
456
- method: "POST",
457
- headers,
458
- path: resolvedPath,
459
- body,
460
- });
312
+ b.m("POST").h(headers).b(body);
313
+ return b.build();
461
314
  };
462
315
  export const se_ListTagsForResourceCommand = async (input, context) => {
463
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
316
+ const b = rb(input, context);
464
317
  const headers = {
465
318
  "content-type": "application/json",
466
319
  };
467
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListTagsForResource";
320
+ b.bp("/ListTagsForResource");
468
321
  let body;
469
322
  body = JSON.stringify(take(input, {
470
323
  NextToken: [],
471
324
  ResourceARN: [],
472
325
  }));
473
- return new __HttpRequest({
474
- protocol,
475
- hostname,
476
- port,
477
- method: "POST",
478
- headers,
479
- path: resolvedPath,
480
- body,
481
- });
326
+ b.m("POST").h(headers).b(body);
327
+ return b.build();
482
328
  };
483
329
  export const se_PutEncryptionConfigCommand = async (input, context) => {
484
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
330
+ const b = rb(input, context);
485
331
  const headers = {
486
332
  "content-type": "application/json",
487
333
  };
488
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutEncryptionConfig";
334
+ b.bp("/PutEncryptionConfig");
489
335
  let body;
490
336
  body = JSON.stringify(take(input, {
491
337
  KeyId: [],
492
338
  Type: [],
493
339
  }));
494
- return new __HttpRequest({
495
- protocol,
496
- hostname,
497
- port,
498
- method: "POST",
499
- headers,
500
- path: resolvedPath,
501
- body,
502
- });
340
+ b.m("POST").h(headers).b(body);
341
+ return b.build();
503
342
  };
504
343
  export const se_PutResourcePolicyCommand = async (input, context) => {
505
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
344
+ const b = rb(input, context);
506
345
  const headers = {
507
346
  "content-type": "application/json",
508
347
  };
509
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutResourcePolicy";
348
+ b.bp("/PutResourcePolicy");
510
349
  let body;
511
350
  body = JSON.stringify(take(input, {
512
351
  BypassPolicyLockoutCheck: [],
@@ -514,22 +353,15 @@ export const se_PutResourcePolicyCommand = async (input, context) => {
514
353
  PolicyName: [],
515
354
  PolicyRevisionId: [],
516
355
  }));
517
- return new __HttpRequest({
518
- protocol,
519
- hostname,
520
- port,
521
- method: "POST",
522
- headers,
523
- path: resolvedPath,
524
- body,
525
- });
356
+ b.m("POST").h(headers).b(body);
357
+ return b.build();
526
358
  };
527
359
  export const se_PutTelemetryRecordsCommand = async (input, context) => {
528
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
360
+ const b = rb(input, context);
529
361
  const headers = {
530
362
  "content-type": "application/json",
531
363
  };
532
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TelemetryRecords";
364
+ b.bp("/TelemetryRecords");
533
365
  let body;
534
366
  body = JSON.stringify(take(input, {
535
367
  EC2InstanceId: [],
@@ -537,84 +369,56 @@ export const se_PutTelemetryRecordsCommand = async (input, context) => {
537
369
  ResourceARN: [],
538
370
  TelemetryRecords: (_) => se_TelemetryRecordList(_, context),
539
371
  }));
540
- return new __HttpRequest({
541
- protocol,
542
- hostname,
543
- port,
544
- method: "POST",
545
- headers,
546
- path: resolvedPath,
547
- body,
548
- });
372
+ b.m("POST").h(headers).b(body);
373
+ return b.build();
549
374
  };
550
375
  export const se_PutTraceSegmentsCommand = async (input, context) => {
551
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
376
+ const b = rb(input, context);
552
377
  const headers = {
553
378
  "content-type": "application/json",
554
379
  };
555
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TraceSegments";
380
+ b.bp("/TraceSegments");
556
381
  let body;
557
382
  body = JSON.stringify(take(input, {
558
383
  TraceSegmentDocuments: (_) => _json(_),
559
384
  }));
560
- return new __HttpRequest({
561
- protocol,
562
- hostname,
563
- port,
564
- method: "POST",
565
- headers,
566
- path: resolvedPath,
567
- body,
568
- });
385
+ b.m("POST").h(headers).b(body);
386
+ return b.build();
569
387
  };
570
388
  export const se_TagResourceCommand = async (input, context) => {
571
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
389
+ const b = rb(input, context);
572
390
  const headers = {
573
391
  "content-type": "application/json",
574
392
  };
575
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TagResource";
393
+ b.bp("/TagResource");
576
394
  let body;
577
395
  body = JSON.stringify(take(input, {
578
396
  ResourceARN: [],
579
397
  Tags: (_) => _json(_),
580
398
  }));
581
- return new __HttpRequest({
582
- protocol,
583
- hostname,
584
- port,
585
- method: "POST",
586
- headers,
587
- path: resolvedPath,
588
- body,
589
- });
399
+ b.m("POST").h(headers).b(body);
400
+ return b.build();
590
401
  };
591
402
  export const se_UntagResourceCommand = async (input, context) => {
592
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
403
+ const b = rb(input, context);
593
404
  const headers = {
594
405
  "content-type": "application/json",
595
406
  };
596
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UntagResource";
407
+ b.bp("/UntagResource");
597
408
  let body;
598
409
  body = JSON.stringify(take(input, {
599
410
  ResourceARN: [],
600
411
  TagKeys: (_) => _json(_),
601
412
  }));
602
- return new __HttpRequest({
603
- protocol,
604
- hostname,
605
- port,
606
- method: "POST",
607
- headers,
608
- path: resolvedPath,
609
- body,
610
- });
413
+ b.m("POST").h(headers).b(body);
414
+ return b.build();
611
415
  };
612
416
  export const se_UpdateGroupCommand = async (input, context) => {
613
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
417
+ const b = rb(input, context);
614
418
  const headers = {
615
419
  "content-type": "application/json",
616
420
  };
617
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateGroup";
421
+ b.bp("/UpdateGroup");
618
422
  let body;
619
423
  body = JSON.stringify(take(input, {
620
424
  FilterExpression: [],
@@ -622,35 +426,21 @@ export const se_UpdateGroupCommand = async (input, context) => {
622
426
  GroupName: [],
623
427
  InsightsConfiguration: (_) => _json(_),
624
428
  }));
625
- return new __HttpRequest({
626
- protocol,
627
- hostname,
628
- port,
629
- method: "POST",
630
- headers,
631
- path: resolvedPath,
632
- body,
633
- });
429
+ b.m("POST").h(headers).b(body);
430
+ return b.build();
634
431
  };
635
432
  export const se_UpdateSamplingRuleCommand = async (input, context) => {
636
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
637
434
  const headers = {
638
435
  "content-type": "application/json",
639
436
  };
640
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateSamplingRule";
437
+ b.bp("/UpdateSamplingRule");
641
438
  let body;
642
439
  body = JSON.stringify(take(input, {
643
440
  SamplingRuleUpdate: (_) => se_SamplingRuleUpdate(_, context),
644
441
  }));
645
- return new __HttpRequest({
646
- protocol,
647
- hostname,
648
- port,
649
- method: "POST",
650
- headers,
651
- path: resolvedPath,
652
- body,
653
- });
442
+ b.m("POST").h(headers).b(body);
443
+ return b.build();
654
444
  };
655
445
  export const de_BatchGetTracesCommand = async (output, context) => {
656
446
  if (output.statusCode !== 200 && output.statusCode >= 300) {