@aws-sdk/client-location 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.
- package/dist-cjs/protocols/Aws_restJson1.js +380 -754
- package/dist-es/protocols/Aws_restJson1.js +382 -756
- package/package.json +5 -4
|
@@ -1,15 +1,15 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
1
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
2
|
+
import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
|
|
3
|
+
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
|
|
3
4
|
import { LocationServiceException as __BaseException } from "../models/LocationServiceException";
|
|
4
5
|
import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
|
|
5
6
|
export const se_AssociateTrackerConsumerCommand = async (input, context) => {
|
|
6
|
-
const
|
|
7
|
+
const b = rb(input, context);
|
|
7
8
|
const headers = {
|
|
8
9
|
"content-type": "application/json",
|
|
9
10
|
};
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
11
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/consumers");
|
|
12
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
13
13
|
let body;
|
|
14
14
|
body = JSON.stringify(take(input, {
|
|
15
15
|
ConsumerArn: [],
|
|
@@ -21,24 +21,17 @@ export const se_AssociateTrackerConsumerCommand = async (input, context) => {
|
|
|
21
21
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
22
22
|
}
|
|
23
23
|
}
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
port,
|
|
28
|
-
method: "POST",
|
|
29
|
-
headers,
|
|
30
|
-
path: resolvedPath,
|
|
31
|
-
body,
|
|
32
|
-
});
|
|
24
|
+
b.hn(resolvedHostname);
|
|
25
|
+
b.m("POST").h(headers).b(body);
|
|
26
|
+
return b.build();
|
|
33
27
|
};
|
|
34
28
|
export const se_BatchDeleteDevicePositionHistoryCommand = async (input, context) => {
|
|
35
|
-
const
|
|
29
|
+
const b = rb(input, context);
|
|
36
30
|
const headers = {
|
|
37
31
|
"content-type": "application/json",
|
|
38
32
|
};
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
33
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/delete-positions");
|
|
34
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
42
35
|
let body;
|
|
43
36
|
body = JSON.stringify(take(input, {
|
|
44
37
|
DeviceIds: (_) => _json(_),
|
|
@@ -50,24 +43,17 @@ export const se_BatchDeleteDevicePositionHistoryCommand = async (input, context)
|
|
|
50
43
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
51
44
|
}
|
|
52
45
|
}
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
port,
|
|
57
|
-
method: "POST",
|
|
58
|
-
headers,
|
|
59
|
-
path: resolvedPath,
|
|
60
|
-
body,
|
|
61
|
-
});
|
|
46
|
+
b.hn(resolvedHostname);
|
|
47
|
+
b.m("POST").h(headers).b(body);
|
|
48
|
+
return b.build();
|
|
62
49
|
};
|
|
63
50
|
export const se_BatchDeleteGeofenceCommand = async (input, context) => {
|
|
64
|
-
const
|
|
51
|
+
const b = rb(input, context);
|
|
65
52
|
const headers = {
|
|
66
53
|
"content-type": "application/json",
|
|
67
54
|
};
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
55
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/delete-geofences");
|
|
56
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
71
57
|
let body;
|
|
72
58
|
body = JSON.stringify(take(input, {
|
|
73
59
|
GeofenceIds: (_) => _json(_),
|
|
@@ -79,24 +65,17 @@ export const se_BatchDeleteGeofenceCommand = async (input, context) => {
|
|
|
79
65
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
80
66
|
}
|
|
81
67
|
}
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
port,
|
|
86
|
-
method: "POST",
|
|
87
|
-
headers,
|
|
88
|
-
path: resolvedPath,
|
|
89
|
-
body,
|
|
90
|
-
});
|
|
68
|
+
b.hn(resolvedHostname);
|
|
69
|
+
b.m("POST").h(headers).b(body);
|
|
70
|
+
return b.build();
|
|
91
71
|
};
|
|
92
72
|
export const se_BatchEvaluateGeofencesCommand = async (input, context) => {
|
|
93
|
-
const
|
|
73
|
+
const b = rb(input, context);
|
|
94
74
|
const headers = {
|
|
95
75
|
"content-type": "application/json",
|
|
96
76
|
};
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
77
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/positions");
|
|
78
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
100
79
|
let body;
|
|
101
80
|
body = JSON.stringify(take(input, {
|
|
102
81
|
DevicePositionUpdates: (_) => se_DevicePositionUpdateList(_, context),
|
|
@@ -108,24 +87,17 @@ export const se_BatchEvaluateGeofencesCommand = async (input, context) => {
|
|
|
108
87
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
109
88
|
}
|
|
110
89
|
}
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
port,
|
|
115
|
-
method: "POST",
|
|
116
|
-
headers,
|
|
117
|
-
path: resolvedPath,
|
|
118
|
-
body,
|
|
119
|
-
});
|
|
90
|
+
b.hn(resolvedHostname);
|
|
91
|
+
b.m("POST").h(headers).b(body);
|
|
92
|
+
return b.build();
|
|
120
93
|
};
|
|
121
94
|
export const se_BatchGetDevicePositionCommand = async (input, context) => {
|
|
122
|
-
const
|
|
95
|
+
const b = rb(input, context);
|
|
123
96
|
const headers = {
|
|
124
97
|
"content-type": "application/json",
|
|
125
98
|
};
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
99
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/get-positions");
|
|
100
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
129
101
|
let body;
|
|
130
102
|
body = JSON.stringify(take(input, {
|
|
131
103
|
DeviceIds: (_) => _json(_),
|
|
@@ -137,24 +109,17 @@ export const se_BatchGetDevicePositionCommand = async (input, context) => {
|
|
|
137
109
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
138
110
|
}
|
|
139
111
|
}
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
port,
|
|
144
|
-
method: "POST",
|
|
145
|
-
headers,
|
|
146
|
-
path: resolvedPath,
|
|
147
|
-
body,
|
|
148
|
-
});
|
|
112
|
+
b.hn(resolvedHostname);
|
|
113
|
+
b.m("POST").h(headers).b(body);
|
|
114
|
+
return b.build();
|
|
149
115
|
};
|
|
150
116
|
export const se_BatchPutGeofenceCommand = async (input, context) => {
|
|
151
|
-
const
|
|
117
|
+
const b = rb(input, context);
|
|
152
118
|
const headers = {
|
|
153
119
|
"content-type": "application/json",
|
|
154
120
|
};
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
121
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/put-geofences");
|
|
122
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
158
123
|
let body;
|
|
159
124
|
body = JSON.stringify(take(input, {
|
|
160
125
|
Entries: (_) => se_BatchPutGeofenceRequestEntryList(_, context),
|
|
@@ -166,24 +131,17 @@ export const se_BatchPutGeofenceCommand = async (input, context) => {
|
|
|
166
131
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
167
132
|
}
|
|
168
133
|
}
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
port,
|
|
173
|
-
method: "POST",
|
|
174
|
-
headers,
|
|
175
|
-
path: resolvedPath,
|
|
176
|
-
body,
|
|
177
|
-
});
|
|
134
|
+
b.hn(resolvedHostname);
|
|
135
|
+
b.m("POST").h(headers).b(body);
|
|
136
|
+
return b.build();
|
|
178
137
|
};
|
|
179
138
|
export const se_BatchUpdateDevicePositionCommand = async (input, context) => {
|
|
180
|
-
const
|
|
139
|
+
const b = rb(input, context);
|
|
181
140
|
const headers = {
|
|
182
141
|
"content-type": "application/json",
|
|
183
142
|
};
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
143
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/positions");
|
|
144
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
187
145
|
let body;
|
|
188
146
|
body = JSON.stringify(take(input, {
|
|
189
147
|
Updates: (_) => se_DevicePositionUpdateList(_, context),
|
|
@@ -195,26 +153,19 @@ export const se_BatchUpdateDevicePositionCommand = async (input, context) => {
|
|
|
195
153
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
196
154
|
}
|
|
197
155
|
}
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
port,
|
|
202
|
-
method: "POST",
|
|
203
|
-
headers,
|
|
204
|
-
path: resolvedPath,
|
|
205
|
-
body,
|
|
206
|
-
});
|
|
156
|
+
b.hn(resolvedHostname);
|
|
157
|
+
b.m("POST").h(headers).b(body);
|
|
158
|
+
return b.build();
|
|
207
159
|
};
|
|
208
160
|
export const se_CalculateRouteCommand = async (input, context) => {
|
|
209
|
-
const
|
|
161
|
+
const b = rb(input, context);
|
|
210
162
|
const headers = {
|
|
211
163
|
"content-type": "application/json",
|
|
212
164
|
};
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
165
|
+
b.bp("/routes/v0/calculators/{CalculatorName}/calculate/route");
|
|
166
|
+
b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
216
167
|
const query = map({
|
|
217
|
-
|
|
168
|
+
[_k]: [, input[_K]],
|
|
218
169
|
});
|
|
219
170
|
let body;
|
|
220
171
|
body = JSON.stringify(take(input, {
|
|
@@ -238,27 +189,19 @@ export const se_CalculateRouteCommand = async (input, context) => {
|
|
|
238
189
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
239
190
|
}
|
|
240
191
|
}
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
port,
|
|
245
|
-
method: "POST",
|
|
246
|
-
headers,
|
|
247
|
-
path: resolvedPath,
|
|
248
|
-
query,
|
|
249
|
-
body,
|
|
250
|
-
});
|
|
192
|
+
b.hn(resolvedHostname);
|
|
193
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
194
|
+
return b.build();
|
|
251
195
|
};
|
|
252
196
|
export const se_CalculateRouteMatrixCommand = async (input, context) => {
|
|
253
|
-
const
|
|
197
|
+
const b = rb(input, context);
|
|
254
198
|
const headers = {
|
|
255
199
|
"content-type": "application/json",
|
|
256
200
|
};
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
201
|
+
b.bp("/routes/v0/calculators/{CalculatorName}/calculate/route-matrix");
|
|
202
|
+
b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
260
203
|
const query = map({
|
|
261
|
-
|
|
204
|
+
[_k]: [, input[_K]],
|
|
262
205
|
});
|
|
263
206
|
let body;
|
|
264
207
|
body = JSON.stringify(take(input, {
|
|
@@ -278,23 +221,16 @@ export const se_CalculateRouteMatrixCommand = async (input, context) => {
|
|
|
278
221
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
279
222
|
}
|
|
280
223
|
}
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
port,
|
|
285
|
-
method: "POST",
|
|
286
|
-
headers,
|
|
287
|
-
path: resolvedPath,
|
|
288
|
-
query,
|
|
289
|
-
body,
|
|
290
|
-
});
|
|
224
|
+
b.hn(resolvedHostname);
|
|
225
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
226
|
+
return b.build();
|
|
291
227
|
};
|
|
292
228
|
export const se_CreateGeofenceCollectionCommand = async (input, context) => {
|
|
293
|
-
const
|
|
229
|
+
const b = rb(input, context);
|
|
294
230
|
const headers = {
|
|
295
231
|
"content-type": "application/json",
|
|
296
232
|
};
|
|
297
|
-
|
|
233
|
+
b.bp("/geofencing/v0/collections");
|
|
298
234
|
let body;
|
|
299
235
|
body = JSON.stringify(take(input, {
|
|
300
236
|
CollectionName: [],
|
|
@@ -311,22 +247,16 @@ export const se_CreateGeofenceCollectionCommand = async (input, context) => {
|
|
|
311
247
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
312
248
|
}
|
|
313
249
|
}
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
port,
|
|
318
|
-
method: "POST",
|
|
319
|
-
headers,
|
|
320
|
-
path: resolvedPath,
|
|
321
|
-
body,
|
|
322
|
-
});
|
|
250
|
+
b.hn(resolvedHostname);
|
|
251
|
+
b.m("POST").h(headers).b(body);
|
|
252
|
+
return b.build();
|
|
323
253
|
};
|
|
324
254
|
export const se_CreateKeyCommand = async (input, context) => {
|
|
325
|
-
const
|
|
255
|
+
const b = rb(input, context);
|
|
326
256
|
const headers = {
|
|
327
257
|
"content-type": "application/json",
|
|
328
258
|
};
|
|
329
|
-
|
|
259
|
+
b.bp("/metadata/v0/keys");
|
|
330
260
|
let body;
|
|
331
261
|
body = JSON.stringify(take(input, {
|
|
332
262
|
Description: [],
|
|
@@ -343,22 +273,16 @@ export const se_CreateKeyCommand = async (input, context) => {
|
|
|
343
273
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
344
274
|
}
|
|
345
275
|
}
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
port,
|
|
350
|
-
method: "POST",
|
|
351
|
-
headers,
|
|
352
|
-
path: resolvedPath,
|
|
353
|
-
body,
|
|
354
|
-
});
|
|
276
|
+
b.hn(resolvedHostname);
|
|
277
|
+
b.m("POST").h(headers).b(body);
|
|
278
|
+
return b.build();
|
|
355
279
|
};
|
|
356
280
|
export const se_CreateMapCommand = async (input, context) => {
|
|
357
|
-
const
|
|
281
|
+
const b = rb(input, context);
|
|
358
282
|
const headers = {
|
|
359
283
|
"content-type": "application/json",
|
|
360
284
|
};
|
|
361
|
-
|
|
285
|
+
b.bp("/maps/v0/maps");
|
|
362
286
|
let body;
|
|
363
287
|
body = JSON.stringify(take(input, {
|
|
364
288
|
Configuration: (_) => _json(_),
|
|
@@ -374,22 +298,16 @@ export const se_CreateMapCommand = async (input, context) => {
|
|
|
374
298
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
375
299
|
}
|
|
376
300
|
}
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
port,
|
|
381
|
-
method: "POST",
|
|
382
|
-
headers,
|
|
383
|
-
path: resolvedPath,
|
|
384
|
-
body,
|
|
385
|
-
});
|
|
301
|
+
b.hn(resolvedHostname);
|
|
302
|
+
b.m("POST").h(headers).b(body);
|
|
303
|
+
return b.build();
|
|
386
304
|
};
|
|
387
305
|
export const se_CreatePlaceIndexCommand = async (input, context) => {
|
|
388
|
-
const
|
|
306
|
+
const b = rb(input, context);
|
|
389
307
|
const headers = {
|
|
390
308
|
"content-type": "application/json",
|
|
391
309
|
};
|
|
392
|
-
|
|
310
|
+
b.bp("/places/v0/indexes");
|
|
393
311
|
let body;
|
|
394
312
|
body = JSON.stringify(take(input, {
|
|
395
313
|
DataSource: [],
|
|
@@ -406,22 +324,16 @@ export const se_CreatePlaceIndexCommand = async (input, context) => {
|
|
|
406
324
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
407
325
|
}
|
|
408
326
|
}
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
port,
|
|
413
|
-
method: "POST",
|
|
414
|
-
headers,
|
|
415
|
-
path: resolvedPath,
|
|
416
|
-
body,
|
|
417
|
-
});
|
|
327
|
+
b.hn(resolvedHostname);
|
|
328
|
+
b.m("POST").h(headers).b(body);
|
|
329
|
+
return b.build();
|
|
418
330
|
};
|
|
419
331
|
export const se_CreateRouteCalculatorCommand = async (input, context) => {
|
|
420
|
-
const
|
|
332
|
+
const b = rb(input, context);
|
|
421
333
|
const headers = {
|
|
422
334
|
"content-type": "application/json",
|
|
423
335
|
};
|
|
424
|
-
|
|
336
|
+
b.bp("/routes/v0/calculators");
|
|
425
337
|
let body;
|
|
426
338
|
body = JSON.stringify(take(input, {
|
|
427
339
|
CalculatorName: [],
|
|
@@ -437,22 +349,16 @@ export const se_CreateRouteCalculatorCommand = async (input, context) => {
|
|
|
437
349
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
438
350
|
}
|
|
439
351
|
}
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
port,
|
|
444
|
-
method: "POST",
|
|
445
|
-
headers,
|
|
446
|
-
path: resolvedPath,
|
|
447
|
-
body,
|
|
448
|
-
});
|
|
352
|
+
b.hn(resolvedHostname);
|
|
353
|
+
b.m("POST").h(headers).b(body);
|
|
354
|
+
return b.build();
|
|
449
355
|
};
|
|
450
356
|
export const se_CreateTrackerCommand = async (input, context) => {
|
|
451
|
-
const
|
|
357
|
+
const b = rb(input, context);
|
|
452
358
|
const headers = {
|
|
453
359
|
"content-type": "application/json",
|
|
454
360
|
};
|
|
455
|
-
|
|
361
|
+
b.bp("/tracking/v0/trackers");
|
|
456
362
|
let body;
|
|
457
363
|
body = JSON.stringify(take(input, {
|
|
458
364
|
Description: [],
|
|
@@ -472,22 +378,15 @@ export const se_CreateTrackerCommand = async (input, context) => {
|
|
|
472
378
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
473
379
|
}
|
|
474
380
|
}
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
port,
|
|
479
|
-
method: "POST",
|
|
480
|
-
headers,
|
|
481
|
-
path: resolvedPath,
|
|
482
|
-
body,
|
|
483
|
-
});
|
|
381
|
+
b.hn(resolvedHostname);
|
|
382
|
+
b.m("POST").h(headers).b(body);
|
|
383
|
+
return b.build();
|
|
484
384
|
};
|
|
485
385
|
export const se_DeleteGeofenceCollectionCommand = async (input, context) => {
|
|
486
|
-
const
|
|
386
|
+
const b = rb(input, context);
|
|
487
387
|
const headers = {};
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
388
|
+
b.bp("/geofencing/v0/collections/{CollectionName}");
|
|
389
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
491
390
|
let body;
|
|
492
391
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
493
392
|
if (context.disableHostPrefix !== true) {
|
|
@@ -496,21 +395,15 @@ export const se_DeleteGeofenceCollectionCommand = async (input, context) => {
|
|
|
496
395
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
497
396
|
}
|
|
498
397
|
}
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
port,
|
|
503
|
-
method: "DELETE",
|
|
504
|
-
headers,
|
|
505
|
-
path: resolvedPath,
|
|
506
|
-
body,
|
|
507
|
-
});
|
|
398
|
+
b.hn(resolvedHostname);
|
|
399
|
+
b.m("DELETE").h(headers).b(body);
|
|
400
|
+
return b.build();
|
|
508
401
|
};
|
|
509
402
|
export const se_DeleteKeyCommand = async (input, context) => {
|
|
510
|
-
const
|
|
403
|
+
const b = rb(input, context);
|
|
511
404
|
const headers = {};
|
|
512
|
-
|
|
513
|
-
|
|
405
|
+
b.bp("/metadata/v0/keys/{KeyName}");
|
|
406
|
+
b.p("KeyName", () => input.KeyName, "{KeyName}", false);
|
|
514
407
|
let body;
|
|
515
408
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
516
409
|
if (context.disableHostPrefix !== true) {
|
|
@@ -519,21 +412,15 @@ export const se_DeleteKeyCommand = async (input, context) => {
|
|
|
519
412
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
520
413
|
}
|
|
521
414
|
}
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
port,
|
|
526
|
-
method: "DELETE",
|
|
527
|
-
headers,
|
|
528
|
-
path: resolvedPath,
|
|
529
|
-
body,
|
|
530
|
-
});
|
|
415
|
+
b.hn(resolvedHostname);
|
|
416
|
+
b.m("DELETE").h(headers).b(body);
|
|
417
|
+
return b.build();
|
|
531
418
|
};
|
|
532
419
|
export const se_DeleteMapCommand = async (input, context) => {
|
|
533
|
-
const
|
|
420
|
+
const b = rb(input, context);
|
|
534
421
|
const headers = {};
|
|
535
|
-
|
|
536
|
-
|
|
422
|
+
b.bp("/maps/v0/maps/{MapName}");
|
|
423
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
537
424
|
let body;
|
|
538
425
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
539
426
|
if (context.disableHostPrefix !== true) {
|
|
@@ -542,21 +429,15 @@ export const se_DeleteMapCommand = async (input, context) => {
|
|
|
542
429
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
543
430
|
}
|
|
544
431
|
}
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
port,
|
|
549
|
-
method: "DELETE",
|
|
550
|
-
headers,
|
|
551
|
-
path: resolvedPath,
|
|
552
|
-
body,
|
|
553
|
-
});
|
|
432
|
+
b.hn(resolvedHostname);
|
|
433
|
+
b.m("DELETE").h(headers).b(body);
|
|
434
|
+
return b.build();
|
|
554
435
|
};
|
|
555
436
|
export const se_DeletePlaceIndexCommand = async (input, context) => {
|
|
556
|
-
const
|
|
437
|
+
const b = rb(input, context);
|
|
557
438
|
const headers = {};
|
|
558
|
-
|
|
559
|
-
|
|
439
|
+
b.bp("/places/v0/indexes/{IndexName}");
|
|
440
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
560
441
|
let body;
|
|
561
442
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
562
443
|
if (context.disableHostPrefix !== true) {
|
|
@@ -565,21 +446,15 @@ export const se_DeletePlaceIndexCommand = async (input, context) => {
|
|
|
565
446
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
566
447
|
}
|
|
567
448
|
}
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
port,
|
|
572
|
-
method: "DELETE",
|
|
573
|
-
headers,
|
|
574
|
-
path: resolvedPath,
|
|
575
|
-
body,
|
|
576
|
-
});
|
|
449
|
+
b.hn(resolvedHostname);
|
|
450
|
+
b.m("DELETE").h(headers).b(body);
|
|
451
|
+
return b.build();
|
|
577
452
|
};
|
|
578
453
|
export const se_DeleteRouteCalculatorCommand = async (input, context) => {
|
|
579
|
-
const
|
|
454
|
+
const b = rb(input, context);
|
|
580
455
|
const headers = {};
|
|
581
|
-
|
|
582
|
-
|
|
456
|
+
b.bp("/routes/v0/calculators/{CalculatorName}");
|
|
457
|
+
b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
583
458
|
let body;
|
|
584
459
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
585
460
|
if (context.disableHostPrefix !== true) {
|
|
@@ -588,21 +463,15 @@ export const se_DeleteRouteCalculatorCommand = async (input, context) => {
|
|
|
588
463
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
589
464
|
}
|
|
590
465
|
}
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
port,
|
|
595
|
-
method: "DELETE",
|
|
596
|
-
headers,
|
|
597
|
-
path: resolvedPath,
|
|
598
|
-
body,
|
|
599
|
-
});
|
|
466
|
+
b.hn(resolvedHostname);
|
|
467
|
+
b.m("DELETE").h(headers).b(body);
|
|
468
|
+
return b.build();
|
|
600
469
|
};
|
|
601
470
|
export const se_DeleteTrackerCommand = async (input, context) => {
|
|
602
|
-
const
|
|
471
|
+
const b = rb(input, context);
|
|
603
472
|
const headers = {};
|
|
604
|
-
|
|
605
|
-
|
|
473
|
+
b.bp("/tracking/v0/trackers/{TrackerName}");
|
|
474
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
606
475
|
let body;
|
|
607
476
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
608
477
|
if (context.disableHostPrefix !== true) {
|
|
@@ -611,22 +480,15 @@ export const se_DeleteTrackerCommand = async (input, context) => {
|
|
|
611
480
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
612
481
|
}
|
|
613
482
|
}
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
port,
|
|
618
|
-
method: "DELETE",
|
|
619
|
-
headers,
|
|
620
|
-
path: resolvedPath,
|
|
621
|
-
body,
|
|
622
|
-
});
|
|
483
|
+
b.hn(resolvedHostname);
|
|
484
|
+
b.m("DELETE").h(headers).b(body);
|
|
485
|
+
return b.build();
|
|
623
486
|
};
|
|
624
487
|
export const se_DescribeGeofenceCollectionCommand = async (input, context) => {
|
|
625
|
-
const
|
|
488
|
+
const b = rb(input, context);
|
|
626
489
|
const headers = {};
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
490
|
+
b.bp("/geofencing/v0/collections/{CollectionName}");
|
|
491
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
630
492
|
let body;
|
|
631
493
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
632
494
|
if (context.disableHostPrefix !== true) {
|
|
@@ -635,21 +497,15 @@ export const se_DescribeGeofenceCollectionCommand = async (input, context) => {
|
|
|
635
497
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
636
498
|
}
|
|
637
499
|
}
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
port,
|
|
642
|
-
method: "GET",
|
|
643
|
-
headers,
|
|
644
|
-
path: resolvedPath,
|
|
645
|
-
body,
|
|
646
|
-
});
|
|
500
|
+
b.hn(resolvedHostname);
|
|
501
|
+
b.m("GET").h(headers).b(body);
|
|
502
|
+
return b.build();
|
|
647
503
|
};
|
|
648
504
|
export const se_DescribeKeyCommand = async (input, context) => {
|
|
649
|
-
const
|
|
505
|
+
const b = rb(input, context);
|
|
650
506
|
const headers = {};
|
|
651
|
-
|
|
652
|
-
|
|
507
|
+
b.bp("/metadata/v0/keys/{KeyName}");
|
|
508
|
+
b.p("KeyName", () => input.KeyName, "{KeyName}", false);
|
|
653
509
|
let body;
|
|
654
510
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
655
511
|
if (context.disableHostPrefix !== true) {
|
|
@@ -658,21 +514,15 @@ export const se_DescribeKeyCommand = async (input, context) => {
|
|
|
658
514
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
659
515
|
}
|
|
660
516
|
}
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
port,
|
|
665
|
-
method: "GET",
|
|
666
|
-
headers,
|
|
667
|
-
path: resolvedPath,
|
|
668
|
-
body,
|
|
669
|
-
});
|
|
517
|
+
b.hn(resolvedHostname);
|
|
518
|
+
b.m("GET").h(headers).b(body);
|
|
519
|
+
return b.build();
|
|
670
520
|
};
|
|
671
521
|
export const se_DescribeMapCommand = async (input, context) => {
|
|
672
|
-
const
|
|
522
|
+
const b = rb(input, context);
|
|
673
523
|
const headers = {};
|
|
674
|
-
|
|
675
|
-
|
|
524
|
+
b.bp("/maps/v0/maps/{MapName}");
|
|
525
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
676
526
|
let body;
|
|
677
527
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
678
528
|
if (context.disableHostPrefix !== true) {
|
|
@@ -681,21 +531,15 @@ export const se_DescribeMapCommand = async (input, context) => {
|
|
|
681
531
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
682
532
|
}
|
|
683
533
|
}
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
port,
|
|
688
|
-
method: "GET",
|
|
689
|
-
headers,
|
|
690
|
-
path: resolvedPath,
|
|
691
|
-
body,
|
|
692
|
-
});
|
|
534
|
+
b.hn(resolvedHostname);
|
|
535
|
+
b.m("GET").h(headers).b(body);
|
|
536
|
+
return b.build();
|
|
693
537
|
};
|
|
694
538
|
export const se_DescribePlaceIndexCommand = async (input, context) => {
|
|
695
|
-
const
|
|
539
|
+
const b = rb(input, context);
|
|
696
540
|
const headers = {};
|
|
697
|
-
|
|
698
|
-
|
|
541
|
+
b.bp("/places/v0/indexes/{IndexName}");
|
|
542
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
699
543
|
let body;
|
|
700
544
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
701
545
|
if (context.disableHostPrefix !== true) {
|
|
@@ -704,21 +548,15 @@ export const se_DescribePlaceIndexCommand = async (input, context) => {
|
|
|
704
548
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
705
549
|
}
|
|
706
550
|
}
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
port,
|
|
711
|
-
method: "GET",
|
|
712
|
-
headers,
|
|
713
|
-
path: resolvedPath,
|
|
714
|
-
body,
|
|
715
|
-
});
|
|
551
|
+
b.hn(resolvedHostname);
|
|
552
|
+
b.m("GET").h(headers).b(body);
|
|
553
|
+
return b.build();
|
|
716
554
|
};
|
|
717
555
|
export const se_DescribeRouteCalculatorCommand = async (input, context) => {
|
|
718
|
-
const
|
|
556
|
+
const b = rb(input, context);
|
|
719
557
|
const headers = {};
|
|
720
|
-
|
|
721
|
-
|
|
558
|
+
b.bp("/routes/v0/calculators/{CalculatorName}");
|
|
559
|
+
b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
722
560
|
let body;
|
|
723
561
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
724
562
|
if (context.disableHostPrefix !== true) {
|
|
@@ -727,21 +565,15 @@ export const se_DescribeRouteCalculatorCommand = async (input, context) => {
|
|
|
727
565
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
728
566
|
}
|
|
729
567
|
}
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
port,
|
|
734
|
-
method: "GET",
|
|
735
|
-
headers,
|
|
736
|
-
path: resolvedPath,
|
|
737
|
-
body,
|
|
738
|
-
});
|
|
568
|
+
b.hn(resolvedHostname);
|
|
569
|
+
b.m("GET").h(headers).b(body);
|
|
570
|
+
return b.build();
|
|
739
571
|
};
|
|
740
572
|
export const se_DescribeTrackerCommand = async (input, context) => {
|
|
741
|
-
const
|
|
573
|
+
const b = rb(input, context);
|
|
742
574
|
const headers = {};
|
|
743
|
-
|
|
744
|
-
|
|
575
|
+
b.bp("/tracking/v0/trackers/{TrackerName}");
|
|
576
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
745
577
|
let body;
|
|
746
578
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
747
579
|
if (context.disableHostPrefix !== true) {
|
|
@@ -750,23 +582,16 @@ export const se_DescribeTrackerCommand = async (input, context) => {
|
|
|
750
582
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
751
583
|
}
|
|
752
584
|
}
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
port,
|
|
757
|
-
method: "GET",
|
|
758
|
-
headers,
|
|
759
|
-
path: resolvedPath,
|
|
760
|
-
body,
|
|
761
|
-
});
|
|
585
|
+
b.hn(resolvedHostname);
|
|
586
|
+
b.m("GET").h(headers).b(body);
|
|
587
|
+
return b.build();
|
|
762
588
|
};
|
|
763
589
|
export const se_DisassociateTrackerConsumerCommand = async (input, context) => {
|
|
764
|
-
const
|
|
590
|
+
const b = rb(input, context);
|
|
765
591
|
const headers = {};
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ConsumerArn", () => input.ConsumerArn, "{ConsumerArn}", false);
|
|
592
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/consumers/{ConsumerArn}");
|
|
593
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
594
|
+
b.p("ConsumerArn", () => input.ConsumerArn, "{ConsumerArn}", false);
|
|
770
595
|
let body;
|
|
771
596
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
772
597
|
if (context.disableHostPrefix !== true) {
|
|
@@ -775,23 +600,16 @@ export const se_DisassociateTrackerConsumerCommand = async (input, context) => {
|
|
|
775
600
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
776
601
|
}
|
|
777
602
|
}
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
port,
|
|
782
|
-
method: "DELETE",
|
|
783
|
-
headers,
|
|
784
|
-
path: resolvedPath,
|
|
785
|
-
body,
|
|
786
|
-
});
|
|
603
|
+
b.hn(resolvedHostname);
|
|
604
|
+
b.m("DELETE").h(headers).b(body);
|
|
605
|
+
return b.build();
|
|
787
606
|
};
|
|
788
607
|
export const se_GetDevicePositionCommand = async (input, context) => {
|
|
789
|
-
const
|
|
608
|
+
const b = rb(input, context);
|
|
790
609
|
const headers = {};
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
|
|
610
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/positions/latest");
|
|
611
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
612
|
+
b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
|
|
795
613
|
let body;
|
|
796
614
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
797
615
|
if (context.disableHostPrefix !== true) {
|
|
@@ -800,25 +618,18 @@ export const se_GetDevicePositionCommand = async (input, context) => {
|
|
|
800
618
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
801
619
|
}
|
|
802
620
|
}
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
port,
|
|
807
|
-
method: "GET",
|
|
808
|
-
headers,
|
|
809
|
-
path: resolvedPath,
|
|
810
|
-
body,
|
|
811
|
-
});
|
|
621
|
+
b.hn(resolvedHostname);
|
|
622
|
+
b.m("GET").h(headers).b(body);
|
|
623
|
+
return b.build();
|
|
812
624
|
};
|
|
813
625
|
export const se_GetDevicePositionHistoryCommand = async (input, context) => {
|
|
814
|
-
const
|
|
626
|
+
const b = rb(input, context);
|
|
815
627
|
const headers = {
|
|
816
628
|
"content-type": "application/json",
|
|
817
629
|
};
|
|
818
|
-
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
|
|
630
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/list-positions");
|
|
631
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
632
|
+
b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
|
|
822
633
|
let body;
|
|
823
634
|
body = JSON.stringify(take(input, {
|
|
824
635
|
EndTimeExclusive: (_) => _.toISOString().split(".")[0] + "Z",
|
|
@@ -833,23 +644,16 @@ export const se_GetDevicePositionHistoryCommand = async (input, context) => {
|
|
|
833
644
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
834
645
|
}
|
|
835
646
|
}
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
port,
|
|
840
|
-
method: "POST",
|
|
841
|
-
headers,
|
|
842
|
-
path: resolvedPath,
|
|
843
|
-
body,
|
|
844
|
-
});
|
|
647
|
+
b.hn(resolvedHostname);
|
|
648
|
+
b.m("POST").h(headers).b(body);
|
|
649
|
+
return b.build();
|
|
845
650
|
};
|
|
846
651
|
export const se_GetGeofenceCommand = async (input, context) => {
|
|
847
|
-
const
|
|
652
|
+
const b = rb(input, context);
|
|
848
653
|
const headers = {};
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
|
|
654
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}");
|
|
655
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
656
|
+
b.p("GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
|
|
853
657
|
let body;
|
|
854
658
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
855
659
|
if (context.disableHostPrefix !== true) {
|
|
@@ -858,26 +662,19 @@ export const se_GetGeofenceCommand = async (input, context) => {
|
|
|
858
662
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
859
663
|
}
|
|
860
664
|
}
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
port,
|
|
865
|
-
method: "GET",
|
|
866
|
-
headers,
|
|
867
|
-
path: resolvedPath,
|
|
868
|
-
body,
|
|
869
|
-
});
|
|
665
|
+
b.hn(resolvedHostname);
|
|
666
|
+
b.m("GET").h(headers).b(body);
|
|
667
|
+
return b.build();
|
|
870
668
|
};
|
|
871
669
|
export const se_GetMapGlyphsCommand = async (input, context) => {
|
|
872
|
-
const
|
|
670
|
+
const b = rb(input, context);
|
|
873
671
|
const headers = {};
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "FontUnicodeRange", () => input.FontUnicodeRange, "{FontUnicodeRange}", false);
|
|
672
|
+
b.bp("/maps/v0/maps/{MapName}/glyphs/{FontStack}/{FontUnicodeRange}");
|
|
673
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
674
|
+
b.p("FontStack", () => input.FontStack, "{FontStack}", false);
|
|
675
|
+
b.p("FontUnicodeRange", () => input.FontUnicodeRange, "{FontUnicodeRange}", false);
|
|
879
676
|
const query = map({
|
|
880
|
-
|
|
677
|
+
[_k]: [, input[_K]],
|
|
881
678
|
});
|
|
882
679
|
let body;
|
|
883
680
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
@@ -887,26 +684,18 @@ export const se_GetMapGlyphsCommand = async (input, context) => {
|
|
|
887
684
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
888
685
|
}
|
|
889
686
|
}
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
port,
|
|
894
|
-
method: "GET",
|
|
895
|
-
headers,
|
|
896
|
-
path: resolvedPath,
|
|
897
|
-
query,
|
|
898
|
-
body,
|
|
899
|
-
});
|
|
687
|
+
b.hn(resolvedHostname);
|
|
688
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
689
|
+
return b.build();
|
|
900
690
|
};
|
|
901
691
|
export const se_GetMapSpritesCommand = async (input, context) => {
|
|
902
|
-
const
|
|
692
|
+
const b = rb(input, context);
|
|
903
693
|
const headers = {};
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "FileName", () => input.FileName, "{FileName}", false);
|
|
694
|
+
b.bp("/maps/v0/maps/{MapName}/sprites/{FileName}");
|
|
695
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
696
|
+
b.p("FileName", () => input.FileName, "{FileName}", false);
|
|
908
697
|
const query = map({
|
|
909
|
-
|
|
698
|
+
[_k]: [, input[_K]],
|
|
910
699
|
});
|
|
911
700
|
let body;
|
|
912
701
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
@@ -916,24 +705,17 @@ export const se_GetMapSpritesCommand = async (input, context) => {
|
|
|
916
705
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
917
706
|
}
|
|
918
707
|
}
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
port,
|
|
923
|
-
method: "GET",
|
|
924
|
-
headers,
|
|
925
|
-
path: resolvedPath,
|
|
926
|
-
query,
|
|
927
|
-
body,
|
|
928
|
-
});
|
|
708
|
+
b.hn(resolvedHostname);
|
|
709
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
710
|
+
return b.build();
|
|
929
711
|
};
|
|
930
712
|
export const se_GetMapStyleDescriptorCommand = async (input, context) => {
|
|
931
|
-
const
|
|
713
|
+
const b = rb(input, context);
|
|
932
714
|
const headers = {};
|
|
933
|
-
|
|
934
|
-
|
|
715
|
+
b.bp("/maps/v0/maps/{MapName}/style-descriptor");
|
|
716
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
935
717
|
const query = map({
|
|
936
|
-
|
|
718
|
+
[_k]: [, input[_K]],
|
|
937
719
|
});
|
|
938
720
|
let body;
|
|
939
721
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
@@ -943,27 +725,20 @@ export const se_GetMapStyleDescriptorCommand = async (input, context) => {
|
|
|
943
725
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
944
726
|
}
|
|
945
727
|
}
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
port,
|
|
950
|
-
method: "GET",
|
|
951
|
-
headers,
|
|
952
|
-
path: resolvedPath,
|
|
953
|
-
query,
|
|
954
|
-
body,
|
|
955
|
-
});
|
|
728
|
+
b.hn(resolvedHostname);
|
|
729
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
730
|
+
return b.build();
|
|
956
731
|
};
|
|
957
732
|
export const se_GetMapTileCommand = async (input, context) => {
|
|
958
|
-
const
|
|
733
|
+
const b = rb(input, context);
|
|
959
734
|
const headers = {};
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
735
|
+
b.bp("/maps/v0/maps/{MapName}/tiles/{Z}/{X}/{Y}");
|
|
736
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
737
|
+
b.p("Z", () => input.Z, "{Z}", false);
|
|
738
|
+
b.p("X", () => input.X, "{X}", false);
|
|
739
|
+
b.p("Y", () => input.Y, "{Y}", false);
|
|
965
740
|
const query = map({
|
|
966
|
-
|
|
741
|
+
[_k]: [, input[_K]],
|
|
967
742
|
});
|
|
968
743
|
let body;
|
|
969
744
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
@@ -973,27 +748,19 @@ export const se_GetMapTileCommand = async (input, context) => {
|
|
|
973
748
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
974
749
|
}
|
|
975
750
|
}
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
port,
|
|
980
|
-
method: "GET",
|
|
981
|
-
headers,
|
|
982
|
-
path: resolvedPath,
|
|
983
|
-
query,
|
|
984
|
-
body,
|
|
985
|
-
});
|
|
751
|
+
b.hn(resolvedHostname);
|
|
752
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
753
|
+
return b.build();
|
|
986
754
|
};
|
|
987
755
|
export const se_GetPlaceCommand = async (input, context) => {
|
|
988
|
-
const
|
|
756
|
+
const b = rb(input, context);
|
|
989
757
|
const headers = {};
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "PlaceId", () => input.PlaceId, "{PlaceId}", false);
|
|
758
|
+
b.bp("/places/v0/indexes/{IndexName}/places/{PlaceId}");
|
|
759
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
760
|
+
b.p("PlaceId", () => input.PlaceId, "{PlaceId}", false);
|
|
994
761
|
const query = map({
|
|
995
|
-
|
|
996
|
-
|
|
762
|
+
[_l]: [, input[_L]],
|
|
763
|
+
[_k]: [, input[_K]],
|
|
997
764
|
});
|
|
998
765
|
let body;
|
|
999
766
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
@@ -1003,25 +770,17 @@ export const se_GetPlaceCommand = async (input, context) => {
|
|
|
1003
770
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1004
771
|
}
|
|
1005
772
|
}
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
port,
|
|
1010
|
-
method: "GET",
|
|
1011
|
-
headers,
|
|
1012
|
-
path: resolvedPath,
|
|
1013
|
-
query,
|
|
1014
|
-
body,
|
|
1015
|
-
});
|
|
773
|
+
b.hn(resolvedHostname);
|
|
774
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
775
|
+
return b.build();
|
|
1016
776
|
};
|
|
1017
777
|
export const se_ListDevicePositionsCommand = async (input, context) => {
|
|
1018
|
-
const
|
|
778
|
+
const b = rb(input, context);
|
|
1019
779
|
const headers = {
|
|
1020
780
|
"content-type": "application/json",
|
|
1021
781
|
};
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
782
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/list-positions");
|
|
783
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
1025
784
|
let body;
|
|
1026
785
|
body = JSON.stringify(take(input, {
|
|
1027
786
|
FilterGeometry: (_) => se_TrackingFilterGeometry(_, context),
|
|
@@ -1035,22 +794,16 @@ export const se_ListDevicePositionsCommand = async (input, context) => {
|
|
|
1035
794
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1036
795
|
}
|
|
1037
796
|
}
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
port,
|
|
1042
|
-
method: "POST",
|
|
1043
|
-
headers,
|
|
1044
|
-
path: resolvedPath,
|
|
1045
|
-
body,
|
|
1046
|
-
});
|
|
797
|
+
b.hn(resolvedHostname);
|
|
798
|
+
b.m("POST").h(headers).b(body);
|
|
799
|
+
return b.build();
|
|
1047
800
|
};
|
|
1048
801
|
export const se_ListGeofenceCollectionsCommand = async (input, context) => {
|
|
1049
|
-
const
|
|
802
|
+
const b = rb(input, context);
|
|
1050
803
|
const headers = {
|
|
1051
804
|
"content-type": "application/json",
|
|
1052
805
|
};
|
|
1053
|
-
|
|
806
|
+
b.bp("/geofencing/v0/list-collections");
|
|
1054
807
|
let body;
|
|
1055
808
|
body = JSON.stringify(take(input, {
|
|
1056
809
|
MaxResults: [],
|
|
@@ -1063,24 +816,17 @@ export const se_ListGeofenceCollectionsCommand = async (input, context) => {
|
|
|
1063
816
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1064
817
|
}
|
|
1065
818
|
}
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
port,
|
|
1070
|
-
method: "POST",
|
|
1071
|
-
headers,
|
|
1072
|
-
path: resolvedPath,
|
|
1073
|
-
body,
|
|
1074
|
-
});
|
|
819
|
+
b.hn(resolvedHostname);
|
|
820
|
+
b.m("POST").h(headers).b(body);
|
|
821
|
+
return b.build();
|
|
1075
822
|
};
|
|
1076
823
|
export const se_ListGeofencesCommand = async (input, context) => {
|
|
1077
|
-
const
|
|
824
|
+
const b = rb(input, context);
|
|
1078
825
|
const headers = {
|
|
1079
826
|
"content-type": "application/json",
|
|
1080
827
|
};
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
828
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/list-geofences");
|
|
829
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
1084
830
|
let body;
|
|
1085
831
|
body = JSON.stringify(take(input, {
|
|
1086
832
|
MaxResults: [],
|
|
@@ -1093,22 +839,16 @@ export const se_ListGeofencesCommand = async (input, context) => {
|
|
|
1093
839
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1094
840
|
}
|
|
1095
841
|
}
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
port,
|
|
1100
|
-
method: "POST",
|
|
1101
|
-
headers,
|
|
1102
|
-
path: resolvedPath,
|
|
1103
|
-
body,
|
|
1104
|
-
});
|
|
842
|
+
b.hn(resolvedHostname);
|
|
843
|
+
b.m("POST").h(headers).b(body);
|
|
844
|
+
return b.build();
|
|
1105
845
|
};
|
|
1106
846
|
export const se_ListKeysCommand = async (input, context) => {
|
|
1107
|
-
const
|
|
847
|
+
const b = rb(input, context);
|
|
1108
848
|
const headers = {
|
|
1109
849
|
"content-type": "application/json",
|
|
1110
850
|
};
|
|
1111
|
-
|
|
851
|
+
b.bp("/metadata/v0/list-keys");
|
|
1112
852
|
let body;
|
|
1113
853
|
body = JSON.stringify(take(input, {
|
|
1114
854
|
Filter: (_) => _json(_),
|
|
@@ -1122,22 +862,16 @@ export const se_ListKeysCommand = async (input, context) => {
|
|
|
1122
862
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1123
863
|
}
|
|
1124
864
|
}
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
port,
|
|
1129
|
-
method: "POST",
|
|
1130
|
-
headers,
|
|
1131
|
-
path: resolvedPath,
|
|
1132
|
-
body,
|
|
1133
|
-
});
|
|
865
|
+
b.hn(resolvedHostname);
|
|
866
|
+
b.m("POST").h(headers).b(body);
|
|
867
|
+
return b.build();
|
|
1134
868
|
};
|
|
1135
869
|
export const se_ListMapsCommand = async (input, context) => {
|
|
1136
|
-
const
|
|
870
|
+
const b = rb(input, context);
|
|
1137
871
|
const headers = {
|
|
1138
872
|
"content-type": "application/json",
|
|
1139
873
|
};
|
|
1140
|
-
|
|
874
|
+
b.bp("/maps/v0/list-maps");
|
|
1141
875
|
let body;
|
|
1142
876
|
body = JSON.stringify(take(input, {
|
|
1143
877
|
MaxResults: [],
|
|
@@ -1150,22 +884,16 @@ export const se_ListMapsCommand = async (input, context) => {
|
|
|
1150
884
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1151
885
|
}
|
|
1152
886
|
}
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
port,
|
|
1157
|
-
method: "POST",
|
|
1158
|
-
headers,
|
|
1159
|
-
path: resolvedPath,
|
|
1160
|
-
body,
|
|
1161
|
-
});
|
|
887
|
+
b.hn(resolvedHostname);
|
|
888
|
+
b.m("POST").h(headers).b(body);
|
|
889
|
+
return b.build();
|
|
1162
890
|
};
|
|
1163
891
|
export const se_ListPlaceIndexesCommand = async (input, context) => {
|
|
1164
|
-
const
|
|
892
|
+
const b = rb(input, context);
|
|
1165
893
|
const headers = {
|
|
1166
894
|
"content-type": "application/json",
|
|
1167
895
|
};
|
|
1168
|
-
|
|
896
|
+
b.bp("/places/v0/list-indexes");
|
|
1169
897
|
let body;
|
|
1170
898
|
body = JSON.stringify(take(input, {
|
|
1171
899
|
MaxResults: [],
|
|
@@ -1178,22 +906,16 @@ export const se_ListPlaceIndexesCommand = async (input, context) => {
|
|
|
1178
906
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1179
907
|
}
|
|
1180
908
|
}
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
port,
|
|
1185
|
-
method: "POST",
|
|
1186
|
-
headers,
|
|
1187
|
-
path: resolvedPath,
|
|
1188
|
-
body,
|
|
1189
|
-
});
|
|
909
|
+
b.hn(resolvedHostname);
|
|
910
|
+
b.m("POST").h(headers).b(body);
|
|
911
|
+
return b.build();
|
|
1190
912
|
};
|
|
1191
913
|
export const se_ListRouteCalculatorsCommand = async (input, context) => {
|
|
1192
|
-
const
|
|
914
|
+
const b = rb(input, context);
|
|
1193
915
|
const headers = {
|
|
1194
916
|
"content-type": "application/json",
|
|
1195
917
|
};
|
|
1196
|
-
|
|
918
|
+
b.bp("/routes/v0/list-calculators");
|
|
1197
919
|
let body;
|
|
1198
920
|
body = JSON.stringify(take(input, {
|
|
1199
921
|
MaxResults: [],
|
|
@@ -1206,21 +928,15 @@ export const se_ListRouteCalculatorsCommand = async (input, context) => {
|
|
|
1206
928
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1207
929
|
}
|
|
1208
930
|
}
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
port,
|
|
1213
|
-
method: "POST",
|
|
1214
|
-
headers,
|
|
1215
|
-
path: resolvedPath,
|
|
1216
|
-
body,
|
|
1217
|
-
});
|
|
931
|
+
b.hn(resolvedHostname);
|
|
932
|
+
b.m("POST").h(headers).b(body);
|
|
933
|
+
return b.build();
|
|
1218
934
|
};
|
|
1219
935
|
export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
1220
|
-
const
|
|
936
|
+
const b = rb(input, context);
|
|
1221
937
|
const headers = {};
|
|
1222
|
-
|
|
1223
|
-
|
|
938
|
+
b.bp("/tags/{ResourceArn}");
|
|
939
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1224
940
|
let body;
|
|
1225
941
|
let { hostname: resolvedHostname } = await context.endpoint();
|
|
1226
942
|
if (context.disableHostPrefix !== true) {
|
|
@@ -1229,24 +945,17 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
|
1229
945
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1230
946
|
}
|
|
1231
947
|
}
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
port,
|
|
1236
|
-
method: "GET",
|
|
1237
|
-
headers,
|
|
1238
|
-
path: resolvedPath,
|
|
1239
|
-
body,
|
|
1240
|
-
});
|
|
948
|
+
b.hn(resolvedHostname);
|
|
949
|
+
b.m("GET").h(headers).b(body);
|
|
950
|
+
return b.build();
|
|
1241
951
|
};
|
|
1242
952
|
export const se_ListTrackerConsumersCommand = async (input, context) => {
|
|
1243
|
-
const
|
|
953
|
+
const b = rb(input, context);
|
|
1244
954
|
const headers = {
|
|
1245
955
|
"content-type": "application/json",
|
|
1246
956
|
};
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
957
|
+
b.bp("/tracking/v0/trackers/{TrackerName}/list-consumers");
|
|
958
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
1250
959
|
let body;
|
|
1251
960
|
body = JSON.stringify(take(input, {
|
|
1252
961
|
MaxResults: [],
|
|
@@ -1259,22 +968,16 @@ export const se_ListTrackerConsumersCommand = async (input, context) => {
|
|
|
1259
968
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1260
969
|
}
|
|
1261
970
|
}
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
port,
|
|
1266
|
-
method: "POST",
|
|
1267
|
-
headers,
|
|
1268
|
-
path: resolvedPath,
|
|
1269
|
-
body,
|
|
1270
|
-
});
|
|
971
|
+
b.hn(resolvedHostname);
|
|
972
|
+
b.m("POST").h(headers).b(body);
|
|
973
|
+
return b.build();
|
|
1271
974
|
};
|
|
1272
975
|
export const se_ListTrackersCommand = async (input, context) => {
|
|
1273
|
-
const
|
|
976
|
+
const b = rb(input, context);
|
|
1274
977
|
const headers = {
|
|
1275
978
|
"content-type": "application/json",
|
|
1276
979
|
};
|
|
1277
|
-
|
|
980
|
+
b.bp("/tracking/v0/list-trackers");
|
|
1278
981
|
let body;
|
|
1279
982
|
body = JSON.stringify(take(input, {
|
|
1280
983
|
MaxResults: [],
|
|
@@ -1287,25 +990,18 @@ export const se_ListTrackersCommand = async (input, context) => {
|
|
|
1287
990
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1288
991
|
}
|
|
1289
992
|
}
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
port,
|
|
1294
|
-
method: "POST",
|
|
1295
|
-
headers,
|
|
1296
|
-
path: resolvedPath,
|
|
1297
|
-
body,
|
|
1298
|
-
});
|
|
993
|
+
b.hn(resolvedHostname);
|
|
994
|
+
b.m("POST").h(headers).b(body);
|
|
995
|
+
return b.build();
|
|
1299
996
|
};
|
|
1300
997
|
export const se_PutGeofenceCommand = async (input, context) => {
|
|
1301
|
-
const
|
|
998
|
+
const b = rb(input, context);
|
|
1302
999
|
const headers = {
|
|
1303
1000
|
"content-type": "application/json",
|
|
1304
1001
|
};
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
|
|
1002
|
+
b.bp("/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}");
|
|
1003
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
1004
|
+
b.p("GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
|
|
1309
1005
|
let body;
|
|
1310
1006
|
body = JSON.stringify(take(input, {
|
|
1311
1007
|
GeofenceProperties: (_) => _json(_),
|
|
@@ -1318,26 +1014,19 @@ export const se_PutGeofenceCommand = async (input, context) => {
|
|
|
1318
1014
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1319
1015
|
}
|
|
1320
1016
|
}
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
port,
|
|
1325
|
-
method: "PUT",
|
|
1326
|
-
headers,
|
|
1327
|
-
path: resolvedPath,
|
|
1328
|
-
body,
|
|
1329
|
-
});
|
|
1017
|
+
b.hn(resolvedHostname);
|
|
1018
|
+
b.m("PUT").h(headers).b(body);
|
|
1019
|
+
return b.build();
|
|
1330
1020
|
};
|
|
1331
1021
|
export const se_SearchPlaceIndexForPositionCommand = async (input, context) => {
|
|
1332
|
-
const
|
|
1022
|
+
const b = rb(input, context);
|
|
1333
1023
|
const headers = {
|
|
1334
1024
|
"content-type": "application/json",
|
|
1335
1025
|
};
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1026
|
+
b.bp("/places/v0/indexes/{IndexName}/search/position");
|
|
1027
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1339
1028
|
const query = map({
|
|
1340
|
-
|
|
1029
|
+
[_k]: [, input[_K]],
|
|
1341
1030
|
});
|
|
1342
1031
|
let body;
|
|
1343
1032
|
body = JSON.stringify(take(input, {
|
|
@@ -1352,27 +1041,19 @@ export const se_SearchPlaceIndexForPositionCommand = async (input, context) => {
|
|
|
1352
1041
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1353
1042
|
}
|
|
1354
1043
|
}
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
port,
|
|
1359
|
-
method: "POST",
|
|
1360
|
-
headers,
|
|
1361
|
-
path: resolvedPath,
|
|
1362
|
-
query,
|
|
1363
|
-
body,
|
|
1364
|
-
});
|
|
1044
|
+
b.hn(resolvedHostname);
|
|
1045
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
1046
|
+
return b.build();
|
|
1365
1047
|
};
|
|
1366
1048
|
export const se_SearchPlaceIndexForSuggestionsCommand = async (input, context) => {
|
|
1367
|
-
const
|
|
1049
|
+
const b = rb(input, context);
|
|
1368
1050
|
const headers = {
|
|
1369
1051
|
"content-type": "application/json",
|
|
1370
1052
|
};
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1053
|
+
b.bp("/places/v0/indexes/{IndexName}/search/suggestions");
|
|
1054
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1374
1055
|
const query = map({
|
|
1375
|
-
|
|
1056
|
+
[_k]: [, input[_K]],
|
|
1376
1057
|
});
|
|
1377
1058
|
let body;
|
|
1378
1059
|
body = JSON.stringify(take(input, {
|
|
@@ -1391,27 +1072,19 @@ export const se_SearchPlaceIndexForSuggestionsCommand = async (input, context) =
|
|
|
1391
1072
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1392
1073
|
}
|
|
1393
1074
|
}
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
port,
|
|
1398
|
-
method: "POST",
|
|
1399
|
-
headers,
|
|
1400
|
-
path: resolvedPath,
|
|
1401
|
-
query,
|
|
1402
|
-
body,
|
|
1403
|
-
});
|
|
1075
|
+
b.hn(resolvedHostname);
|
|
1076
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
1077
|
+
return b.build();
|
|
1404
1078
|
};
|
|
1405
1079
|
export const se_SearchPlaceIndexForTextCommand = async (input, context) => {
|
|
1406
|
-
const
|
|
1080
|
+
const b = rb(input, context);
|
|
1407
1081
|
const headers = {
|
|
1408
1082
|
"content-type": "application/json",
|
|
1409
1083
|
};
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1084
|
+
b.bp("/places/v0/indexes/{IndexName}/search/text");
|
|
1085
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1413
1086
|
const query = map({
|
|
1414
|
-
|
|
1087
|
+
[_k]: [, input[_K]],
|
|
1415
1088
|
});
|
|
1416
1089
|
let body;
|
|
1417
1090
|
body = JSON.stringify(take(input, {
|
|
@@ -1430,24 +1103,17 @@ export const se_SearchPlaceIndexForTextCommand = async (input, context) => {
|
|
|
1430
1103
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1431
1104
|
}
|
|
1432
1105
|
}
|
|
1433
|
-
|
|
1434
|
-
|
|
1435
|
-
|
|
1436
|
-
port,
|
|
1437
|
-
method: "POST",
|
|
1438
|
-
headers,
|
|
1439
|
-
path: resolvedPath,
|
|
1440
|
-
query,
|
|
1441
|
-
body,
|
|
1442
|
-
});
|
|
1106
|
+
b.hn(resolvedHostname);
|
|
1107
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
1108
|
+
return b.build();
|
|
1443
1109
|
};
|
|
1444
1110
|
export const se_TagResourceCommand = async (input, context) => {
|
|
1445
|
-
const
|
|
1111
|
+
const b = rb(input, context);
|
|
1446
1112
|
const headers = {
|
|
1447
1113
|
"content-type": "application/json",
|
|
1448
1114
|
};
|
|
1449
|
-
|
|
1450
|
-
|
|
1115
|
+
b.bp("/tags/{ResourceArn}");
|
|
1116
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1451
1117
|
let body;
|
|
1452
1118
|
body = JSON.stringify(take(input, {
|
|
1453
1119
|
Tags: (_) => _json(_),
|
|
@@ -1459,25 +1125,19 @@ export const se_TagResourceCommand = async (input, context) => {
|
|
|
1459
1125
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1460
1126
|
}
|
|
1461
1127
|
}
|
|
1462
|
-
|
|
1463
|
-
|
|
1464
|
-
|
|
1465
|
-
port,
|
|
1466
|
-
method: "POST",
|
|
1467
|
-
headers,
|
|
1468
|
-
path: resolvedPath,
|
|
1469
|
-
body,
|
|
1470
|
-
});
|
|
1128
|
+
b.hn(resolvedHostname);
|
|
1129
|
+
b.m("POST").h(headers).b(body);
|
|
1130
|
+
return b.build();
|
|
1471
1131
|
};
|
|
1472
1132
|
export const se_UntagResourceCommand = async (input, context) => {
|
|
1473
|
-
const
|
|
1133
|
+
const b = rb(input, context);
|
|
1474
1134
|
const headers = {};
|
|
1475
|
-
|
|
1476
|
-
|
|
1135
|
+
b.bp("/tags/{ResourceArn}");
|
|
1136
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1477
1137
|
const query = map({
|
|
1478
|
-
|
|
1138
|
+
[_tK]: [
|
|
1479
1139
|
__expectNonNull(input.TagKeys, `TagKeys`) != null,
|
|
1480
|
-
() => (input
|
|
1140
|
+
() => (input[_TK] || []).map((_entry) => _entry),
|
|
1481
1141
|
],
|
|
1482
1142
|
});
|
|
1483
1143
|
let body;
|
|
@@ -1488,25 +1148,17 @@ export const se_UntagResourceCommand = async (input, context) => {
|
|
|
1488
1148
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1489
1149
|
}
|
|
1490
1150
|
}
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
port,
|
|
1495
|
-
method: "DELETE",
|
|
1496
|
-
headers,
|
|
1497
|
-
path: resolvedPath,
|
|
1498
|
-
query,
|
|
1499
|
-
body,
|
|
1500
|
-
});
|
|
1151
|
+
b.hn(resolvedHostname);
|
|
1152
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
1153
|
+
return b.build();
|
|
1501
1154
|
};
|
|
1502
1155
|
export const se_UpdateGeofenceCollectionCommand = async (input, context) => {
|
|
1503
|
-
const
|
|
1156
|
+
const b = rb(input, context);
|
|
1504
1157
|
const headers = {
|
|
1505
1158
|
"content-type": "application/json",
|
|
1506
1159
|
};
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
1160
|
+
b.bp("/geofencing/v0/collections/{CollectionName}");
|
|
1161
|
+
b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
|
|
1510
1162
|
let body;
|
|
1511
1163
|
body = JSON.stringify(take(input, {
|
|
1512
1164
|
Description: [],
|
|
@@ -1520,23 +1172,17 @@ export const se_UpdateGeofenceCollectionCommand = async (input, context) => {
|
|
|
1520
1172
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1521
1173
|
}
|
|
1522
1174
|
}
|
|
1523
|
-
|
|
1524
|
-
|
|
1525
|
-
|
|
1526
|
-
port,
|
|
1527
|
-
method: "PATCH",
|
|
1528
|
-
headers,
|
|
1529
|
-
path: resolvedPath,
|
|
1530
|
-
body,
|
|
1531
|
-
});
|
|
1175
|
+
b.hn(resolvedHostname);
|
|
1176
|
+
b.m("PATCH").h(headers).b(body);
|
|
1177
|
+
return b.build();
|
|
1532
1178
|
};
|
|
1533
1179
|
export const se_UpdateKeyCommand = async (input, context) => {
|
|
1534
|
-
const
|
|
1180
|
+
const b = rb(input, context);
|
|
1535
1181
|
const headers = {
|
|
1536
1182
|
"content-type": "application/json",
|
|
1537
1183
|
};
|
|
1538
|
-
|
|
1539
|
-
|
|
1184
|
+
b.bp("/metadata/v0/keys/{KeyName}");
|
|
1185
|
+
b.p("KeyName", () => input.KeyName, "{KeyName}", false);
|
|
1540
1186
|
let body;
|
|
1541
1187
|
body = JSON.stringify(take(input, {
|
|
1542
1188
|
Description: [],
|
|
@@ -1552,23 +1198,17 @@ export const se_UpdateKeyCommand = async (input, context) => {
|
|
|
1552
1198
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1553
1199
|
}
|
|
1554
1200
|
}
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
|
|
1558
|
-
port,
|
|
1559
|
-
method: "PATCH",
|
|
1560
|
-
headers,
|
|
1561
|
-
path: resolvedPath,
|
|
1562
|
-
body,
|
|
1563
|
-
});
|
|
1201
|
+
b.hn(resolvedHostname);
|
|
1202
|
+
b.m("PATCH").h(headers).b(body);
|
|
1203
|
+
return b.build();
|
|
1564
1204
|
};
|
|
1565
1205
|
export const se_UpdateMapCommand = async (input, context) => {
|
|
1566
|
-
const
|
|
1206
|
+
const b = rb(input, context);
|
|
1567
1207
|
const headers = {
|
|
1568
1208
|
"content-type": "application/json",
|
|
1569
1209
|
};
|
|
1570
|
-
|
|
1571
|
-
|
|
1210
|
+
b.bp("/maps/v0/maps/{MapName}");
|
|
1211
|
+
b.p("MapName", () => input.MapName, "{MapName}", false);
|
|
1572
1212
|
let body;
|
|
1573
1213
|
body = JSON.stringify(take(input, {
|
|
1574
1214
|
ConfigurationUpdate: (_) => _json(_),
|
|
@@ -1582,23 +1222,17 @@ export const se_UpdateMapCommand = async (input, context) => {
|
|
|
1582
1222
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1583
1223
|
}
|
|
1584
1224
|
}
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
port,
|
|
1589
|
-
method: "PATCH",
|
|
1590
|
-
headers,
|
|
1591
|
-
path: resolvedPath,
|
|
1592
|
-
body,
|
|
1593
|
-
});
|
|
1225
|
+
b.hn(resolvedHostname);
|
|
1226
|
+
b.m("PATCH").h(headers).b(body);
|
|
1227
|
+
return b.build();
|
|
1594
1228
|
};
|
|
1595
1229
|
export const se_UpdatePlaceIndexCommand = async (input, context) => {
|
|
1596
|
-
const
|
|
1230
|
+
const b = rb(input, context);
|
|
1597
1231
|
const headers = {
|
|
1598
1232
|
"content-type": "application/json",
|
|
1599
1233
|
};
|
|
1600
|
-
|
|
1601
|
-
|
|
1234
|
+
b.bp("/places/v0/indexes/{IndexName}");
|
|
1235
|
+
b.p("IndexName", () => input.IndexName, "{IndexName}", false);
|
|
1602
1236
|
let body;
|
|
1603
1237
|
body = JSON.stringify(take(input, {
|
|
1604
1238
|
DataSourceConfiguration: (_) => _json(_),
|
|
@@ -1612,23 +1246,17 @@ export const se_UpdatePlaceIndexCommand = async (input, context) => {
|
|
|
1612
1246
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1613
1247
|
}
|
|
1614
1248
|
}
|
|
1615
|
-
|
|
1616
|
-
|
|
1617
|
-
|
|
1618
|
-
port,
|
|
1619
|
-
method: "PATCH",
|
|
1620
|
-
headers,
|
|
1621
|
-
path: resolvedPath,
|
|
1622
|
-
body,
|
|
1623
|
-
});
|
|
1249
|
+
b.hn(resolvedHostname);
|
|
1250
|
+
b.m("PATCH").h(headers).b(body);
|
|
1251
|
+
return b.build();
|
|
1624
1252
|
};
|
|
1625
1253
|
export const se_UpdateRouteCalculatorCommand = async (input, context) => {
|
|
1626
|
-
const
|
|
1254
|
+
const b = rb(input, context);
|
|
1627
1255
|
const headers = {
|
|
1628
1256
|
"content-type": "application/json",
|
|
1629
1257
|
};
|
|
1630
|
-
|
|
1631
|
-
|
|
1258
|
+
b.bp("/routes/v0/calculators/{CalculatorName}");
|
|
1259
|
+
b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
|
|
1632
1260
|
let body;
|
|
1633
1261
|
body = JSON.stringify(take(input, {
|
|
1634
1262
|
Description: [],
|
|
@@ -1641,23 +1269,17 @@ export const se_UpdateRouteCalculatorCommand = async (input, context) => {
|
|
|
1641
1269
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1642
1270
|
}
|
|
1643
1271
|
}
|
|
1644
|
-
|
|
1645
|
-
|
|
1646
|
-
|
|
1647
|
-
port,
|
|
1648
|
-
method: "PATCH",
|
|
1649
|
-
headers,
|
|
1650
|
-
path: resolvedPath,
|
|
1651
|
-
body,
|
|
1652
|
-
});
|
|
1272
|
+
b.hn(resolvedHostname);
|
|
1273
|
+
b.m("PATCH").h(headers).b(body);
|
|
1274
|
+
return b.build();
|
|
1653
1275
|
};
|
|
1654
1276
|
export const se_UpdateTrackerCommand = async (input, context) => {
|
|
1655
|
-
const
|
|
1277
|
+
const b = rb(input, context);
|
|
1656
1278
|
const headers = {
|
|
1657
1279
|
"content-type": "application/json",
|
|
1658
1280
|
};
|
|
1659
|
-
|
|
1660
|
-
|
|
1281
|
+
b.bp("/tracking/v0/trackers/{TrackerName}");
|
|
1282
|
+
b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
|
|
1661
1283
|
let body;
|
|
1662
1284
|
body = JSON.stringify(take(input, {
|
|
1663
1285
|
Description: [],
|
|
@@ -1674,15 +1296,9 @@ export const se_UpdateTrackerCommand = async (input, context) => {
|
|
|
1674
1296
|
throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
|
|
1675
1297
|
}
|
|
1676
1298
|
}
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
port,
|
|
1681
|
-
method: "PATCH",
|
|
1682
|
-
headers,
|
|
1683
|
-
path: resolvedPath,
|
|
1684
|
-
body,
|
|
1685
|
-
});
|
|
1299
|
+
b.hn(resolvedHostname);
|
|
1300
|
+
b.m("PATCH").h(headers).b(body);
|
|
1301
|
+
return b.build();
|
|
1686
1302
|
};
|
|
1687
1303
|
export const de_AssociateTrackerConsumerCommand = async (output, context) => {
|
|
1688
1304
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3158,8 +2774,8 @@ export const de_GetMapGlyphsCommand = async (output, context) => {
|
|
|
3158
2774
|
}
|
|
3159
2775
|
const contents = map({
|
|
3160
2776
|
$metadata: deserializeMetadata(output),
|
|
3161
|
-
|
|
3162
|
-
|
|
2777
|
+
[_CT]: [, output.headers[_ct]],
|
|
2778
|
+
[_CC]: [, output.headers[_cc]],
|
|
3163
2779
|
});
|
|
3164
2780
|
const data = await collectBody(output.body, context);
|
|
3165
2781
|
contents.Blob = data;
|
|
@@ -3202,8 +2818,8 @@ export const de_GetMapSpritesCommand = async (output, context) => {
|
|
|
3202
2818
|
}
|
|
3203
2819
|
const contents = map({
|
|
3204
2820
|
$metadata: deserializeMetadata(output),
|
|
3205
|
-
|
|
3206
|
-
|
|
2821
|
+
[_CT]: [, output.headers[_ct]],
|
|
2822
|
+
[_CC]: [, output.headers[_cc]],
|
|
3207
2823
|
});
|
|
3208
2824
|
const data = await collectBody(output.body, context);
|
|
3209
2825
|
contents.Blob = data;
|
|
@@ -3246,8 +2862,8 @@ export const de_GetMapStyleDescriptorCommand = async (output, context) => {
|
|
|
3246
2862
|
}
|
|
3247
2863
|
const contents = map({
|
|
3248
2864
|
$metadata: deserializeMetadata(output),
|
|
3249
|
-
|
|
3250
|
-
|
|
2865
|
+
[_CT]: [, output.headers[_ct]],
|
|
2866
|
+
[_CC]: [, output.headers[_cc]],
|
|
3251
2867
|
});
|
|
3252
2868
|
const data = await collectBody(output.body, context);
|
|
3253
2869
|
contents.Blob = data;
|
|
@@ -3290,8 +2906,8 @@ export const de_GetMapTileCommand = async (output, context) => {
|
|
|
3290
2906
|
}
|
|
3291
2907
|
const contents = map({
|
|
3292
2908
|
$metadata: deserializeMetadata(output),
|
|
3293
|
-
|
|
3294
|
-
|
|
2909
|
+
[_CT]: [, output.headers[_ct]],
|
|
2910
|
+
[_CC]: [, output.headers[_cc]],
|
|
3295
2911
|
});
|
|
3296
2912
|
const data = await collectBody(output.body, context);
|
|
3297
2913
|
contents.Blob = data;
|
|
@@ -5032,6 +4648,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
5032
4648
|
value !== "" &&
|
|
5033
4649
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
5034
4650
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
4651
|
+
const _CC = "CacheControl";
|
|
4652
|
+
const _CT = "ContentType";
|
|
4653
|
+
const _K = "Key";
|
|
4654
|
+
const _L = "Language";
|
|
4655
|
+
const _TK = "TagKeys";
|
|
4656
|
+
const _cc = "cache-control";
|
|
4657
|
+
const _ct = "content-type";
|
|
4658
|
+
const _k = "key";
|
|
4659
|
+
const _l = "language";
|
|
4660
|
+
const _tK = "tagKeys";
|
|
5035
4661
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
5036
4662
|
if (encoded.length) {
|
|
5037
4663
|
return JSON.parse(encoded);
|