@aws-sdk/client-ecr-public 3.185.0 → 3.188.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 (39) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/dist-es/ECRPUBLIC.js +94 -101
  3. package/dist-es/ECRPUBLICClient.js +22 -28
  4. package/dist-es/commands/BatchCheckLayerAvailabilityCommand.js +21 -28
  5. package/dist-es/commands/BatchDeleteImageCommand.js +21 -28
  6. package/dist-es/commands/CompleteLayerUploadCommand.js +21 -28
  7. package/dist-es/commands/CreateRepositoryCommand.js +21 -28
  8. package/dist-es/commands/DeleteRepositoryCommand.js +21 -28
  9. package/dist-es/commands/DeleteRepositoryPolicyCommand.js +21 -28
  10. package/dist-es/commands/DescribeImageTagsCommand.js +21 -28
  11. package/dist-es/commands/DescribeImagesCommand.js +21 -28
  12. package/dist-es/commands/DescribeRegistriesCommand.js +21 -28
  13. package/dist-es/commands/DescribeRepositoriesCommand.js +21 -28
  14. package/dist-es/commands/GetAuthorizationTokenCommand.js +21 -28
  15. package/dist-es/commands/GetRegistryCatalogDataCommand.js +21 -28
  16. package/dist-es/commands/GetRepositoryCatalogDataCommand.js +21 -28
  17. package/dist-es/commands/GetRepositoryPolicyCommand.js +21 -28
  18. package/dist-es/commands/InitiateLayerUploadCommand.js +21 -28
  19. package/dist-es/commands/ListTagsForResourceCommand.js +21 -28
  20. package/dist-es/commands/PutImageCommand.js +21 -28
  21. package/dist-es/commands/PutRegistryCatalogDataCommand.js +21 -28
  22. package/dist-es/commands/PutRepositoryCatalogDataCommand.js +21 -28
  23. package/dist-es/commands/SetRepositoryPolicyCommand.js +21 -28
  24. package/dist-es/commands/TagResourceCommand.js +21 -28
  25. package/dist-es/commands/UntagResourceCommand.js +21 -28
  26. package/dist-es/commands/UploadLayerPartCommand.js +21 -28
  27. package/dist-es/endpoints.js +8 -8
  28. package/dist-es/models/ECRPUBLICServiceException.js +5 -10
  29. package/dist-es/models/models_0.js +443 -320
  30. package/dist-es/pagination/DescribeImageTagsPaginator.js +25 -68
  31. package/dist-es/pagination/DescribeImagesPaginator.js +25 -68
  32. package/dist-es/pagination/DescribeRegistriesPaginator.js +25 -68
  33. package/dist-es/pagination/DescribeRepositoriesPaginator.js +25 -68
  34. package/dist-es/protocols/Aws_json1_1.js +1747 -2211
  35. package/dist-es/runtimeConfig.browser.js +26 -12
  36. package/dist-es/runtimeConfig.js +30 -12
  37. package/dist-es/runtimeConfig.native.js +8 -5
  38. package/dist-es/runtimeConfig.shared.js +8 -11
  39. package/package.json +33 -33
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1,2105 +1,1664 @@
1
- import { __assign, __awaiter, __generator } from "tslib";
2
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
3
2
  import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
4
3
  import { ECRPUBLICServiceException as __BaseException } from "../models/ECRPUBLICServiceException";
5
4
  import { EmptyUploadException, ImageAlreadyExistsException, ImageDigestDoesNotMatchException, ImageNotFoundException, ImageTagAlreadyExistsException, InvalidLayerException, InvalidLayerPartException, InvalidParameterException, InvalidTagParameterException, LayerAlreadyExistsException, LayerPartTooSmallException, LayersNotFoundException, LimitExceededException, ReferencedImagesNotFoundException, RegistryNotFoundException, RepositoryAlreadyExistsException, RepositoryNotEmptyException, RepositoryNotFoundException, RepositoryPolicyNotFoundException, ServerException, TooManyTagsException, UnsupportedCommandException, UploadNotFoundException, } from "../models/models_0";
6
- export var serializeAws_json1_1BatchCheckLayerAvailabilityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
7
- var headers, body;
8
- return __generator(this, function (_a) {
9
- headers = {
10
- "content-type": "application/x-amz-json-1.1",
11
- "x-amz-target": "SpencerFrontendService.BatchCheckLayerAvailability",
12
- };
13
- body = JSON.stringify(serializeAws_json1_1BatchCheckLayerAvailabilityRequest(input, context));
14
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
15
- });
16
- }); };
17
- export var serializeAws_json1_1BatchDeleteImageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
18
- var headers, body;
19
- return __generator(this, function (_a) {
20
- headers = {
21
- "content-type": "application/x-amz-json-1.1",
22
- "x-amz-target": "SpencerFrontendService.BatchDeleteImage",
23
- };
24
- body = JSON.stringify(serializeAws_json1_1BatchDeleteImageRequest(input, context));
25
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
26
- });
27
- }); };
28
- export var serializeAws_json1_1CompleteLayerUploadCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
29
- var headers, body;
30
- return __generator(this, function (_a) {
31
- headers = {
32
- "content-type": "application/x-amz-json-1.1",
33
- "x-amz-target": "SpencerFrontendService.CompleteLayerUpload",
34
- };
35
- body = JSON.stringify(serializeAws_json1_1CompleteLayerUploadRequest(input, context));
36
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
37
- });
38
- }); };
39
- export var serializeAws_json1_1CreateRepositoryCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
40
- var headers, body;
41
- return __generator(this, function (_a) {
42
- headers = {
43
- "content-type": "application/x-amz-json-1.1",
44
- "x-amz-target": "SpencerFrontendService.CreateRepository",
45
- };
46
- body = JSON.stringify(serializeAws_json1_1CreateRepositoryRequest(input, context));
47
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
48
- });
49
- }); };
50
- export var serializeAws_json1_1DeleteRepositoryCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
51
- var headers, body;
52
- return __generator(this, function (_a) {
53
- headers = {
54
- "content-type": "application/x-amz-json-1.1",
55
- "x-amz-target": "SpencerFrontendService.DeleteRepository",
56
- };
57
- body = JSON.stringify(serializeAws_json1_1DeleteRepositoryRequest(input, context));
58
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
59
- });
60
- }); };
61
- export var serializeAws_json1_1DeleteRepositoryPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
62
- var headers, body;
63
- return __generator(this, function (_a) {
64
- headers = {
65
- "content-type": "application/x-amz-json-1.1",
66
- "x-amz-target": "SpencerFrontendService.DeleteRepositoryPolicy",
67
- };
68
- body = JSON.stringify(serializeAws_json1_1DeleteRepositoryPolicyRequest(input, context));
69
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
70
- });
71
- }); };
72
- export var serializeAws_json1_1DescribeImagesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
73
- var headers, body;
74
- return __generator(this, function (_a) {
75
- headers = {
76
- "content-type": "application/x-amz-json-1.1",
77
- "x-amz-target": "SpencerFrontendService.DescribeImages",
78
- };
79
- body = JSON.stringify(serializeAws_json1_1DescribeImagesRequest(input, context));
80
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
81
- });
82
- }); };
83
- export var serializeAws_json1_1DescribeImageTagsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
84
- var headers, body;
85
- return __generator(this, function (_a) {
86
- headers = {
87
- "content-type": "application/x-amz-json-1.1",
88
- "x-amz-target": "SpencerFrontendService.DescribeImageTags",
89
- };
90
- body = JSON.stringify(serializeAws_json1_1DescribeImageTagsRequest(input, context));
91
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
92
- });
93
- }); };
94
- export var serializeAws_json1_1DescribeRegistriesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
95
- var headers, body;
96
- return __generator(this, function (_a) {
97
- headers = {
98
- "content-type": "application/x-amz-json-1.1",
99
- "x-amz-target": "SpencerFrontendService.DescribeRegistries",
100
- };
101
- body = JSON.stringify(serializeAws_json1_1DescribeRegistriesRequest(input, context));
102
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
103
- });
104
- }); };
105
- export var serializeAws_json1_1DescribeRepositoriesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
106
- var headers, body;
107
- return __generator(this, function (_a) {
108
- headers = {
109
- "content-type": "application/x-amz-json-1.1",
110
- "x-amz-target": "SpencerFrontendService.DescribeRepositories",
111
- };
112
- body = JSON.stringify(serializeAws_json1_1DescribeRepositoriesRequest(input, context));
113
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
114
- });
115
- }); };
116
- export var serializeAws_json1_1GetAuthorizationTokenCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
117
- var headers, body;
118
- return __generator(this, function (_a) {
119
- headers = {
120
- "content-type": "application/x-amz-json-1.1",
121
- "x-amz-target": "SpencerFrontendService.GetAuthorizationToken",
122
- };
123
- body = JSON.stringify(serializeAws_json1_1GetAuthorizationTokenRequest(input, context));
124
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
125
- });
126
- }); };
127
- export var serializeAws_json1_1GetRegistryCatalogDataCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
128
- var headers, body;
129
- return __generator(this, function (_a) {
130
- headers = {
131
- "content-type": "application/x-amz-json-1.1",
132
- "x-amz-target": "SpencerFrontendService.GetRegistryCatalogData",
133
- };
134
- body = JSON.stringify(serializeAws_json1_1GetRegistryCatalogDataRequest(input, context));
135
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
136
- });
137
- }); };
138
- export var serializeAws_json1_1GetRepositoryCatalogDataCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
139
- var headers, body;
140
- return __generator(this, function (_a) {
141
- headers = {
142
- "content-type": "application/x-amz-json-1.1",
143
- "x-amz-target": "SpencerFrontendService.GetRepositoryCatalogData",
144
- };
145
- body = JSON.stringify(serializeAws_json1_1GetRepositoryCatalogDataRequest(input, context));
146
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
147
- });
148
- }); };
149
- export var serializeAws_json1_1GetRepositoryPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
150
- var headers, body;
151
- return __generator(this, function (_a) {
152
- headers = {
153
- "content-type": "application/x-amz-json-1.1",
154
- "x-amz-target": "SpencerFrontendService.GetRepositoryPolicy",
155
- };
156
- body = JSON.stringify(serializeAws_json1_1GetRepositoryPolicyRequest(input, context));
157
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
158
- });
159
- }); };
160
- export var serializeAws_json1_1InitiateLayerUploadCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
161
- var headers, body;
162
- return __generator(this, function (_a) {
163
- headers = {
164
- "content-type": "application/x-amz-json-1.1",
165
- "x-amz-target": "SpencerFrontendService.InitiateLayerUpload",
166
- };
167
- body = JSON.stringify(serializeAws_json1_1InitiateLayerUploadRequest(input, context));
168
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
169
- });
170
- }); };
171
- export var serializeAws_json1_1ListTagsForResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
172
- var headers, body;
173
- return __generator(this, function (_a) {
174
- headers = {
175
- "content-type": "application/x-amz-json-1.1",
176
- "x-amz-target": "SpencerFrontendService.ListTagsForResource",
177
- };
178
- body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
179
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
180
- });
181
- }); };
182
- export var serializeAws_json1_1PutImageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
183
- var headers, body;
184
- return __generator(this, function (_a) {
185
- headers = {
186
- "content-type": "application/x-amz-json-1.1",
187
- "x-amz-target": "SpencerFrontendService.PutImage",
188
- };
189
- body = JSON.stringify(serializeAws_json1_1PutImageRequest(input, context));
190
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
191
- });
192
- }); };
193
- export var serializeAws_json1_1PutRegistryCatalogDataCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
194
- var headers, body;
195
- return __generator(this, function (_a) {
196
- headers = {
197
- "content-type": "application/x-amz-json-1.1",
198
- "x-amz-target": "SpencerFrontendService.PutRegistryCatalogData",
199
- };
200
- body = JSON.stringify(serializeAws_json1_1PutRegistryCatalogDataRequest(input, context));
201
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
202
- });
203
- }); };
204
- export var serializeAws_json1_1PutRepositoryCatalogDataCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
205
- var headers, body;
206
- return __generator(this, function (_a) {
207
- headers = {
208
- "content-type": "application/x-amz-json-1.1",
209
- "x-amz-target": "SpencerFrontendService.PutRepositoryCatalogData",
210
- };
211
- body = JSON.stringify(serializeAws_json1_1PutRepositoryCatalogDataRequest(input, context));
212
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
213
- });
214
- }); };
215
- export var serializeAws_json1_1SetRepositoryPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
216
- var headers, body;
217
- return __generator(this, function (_a) {
218
- headers = {
219
- "content-type": "application/x-amz-json-1.1",
220
- "x-amz-target": "SpencerFrontendService.SetRepositoryPolicy",
221
- };
222
- body = JSON.stringify(serializeAws_json1_1SetRepositoryPolicyRequest(input, context));
223
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
224
- });
225
- }); };
226
- export var serializeAws_json1_1TagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
227
- var headers, body;
228
- return __generator(this, function (_a) {
229
- headers = {
230
- "content-type": "application/x-amz-json-1.1",
231
- "x-amz-target": "SpencerFrontendService.TagResource",
232
- };
233
- body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
234
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
235
- });
236
- }); };
237
- export var serializeAws_json1_1UntagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
238
- var headers, body;
239
- return __generator(this, function (_a) {
240
- headers = {
241
- "content-type": "application/x-amz-json-1.1",
242
- "x-amz-target": "SpencerFrontendService.UntagResource",
243
- };
244
- body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
245
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
246
- });
247
- }); };
248
- export var serializeAws_json1_1UploadLayerPartCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
249
- var headers, body;
250
- return __generator(this, function (_a) {
251
- headers = {
252
- "content-type": "application/x-amz-json-1.1",
253
- "x-amz-target": "SpencerFrontendService.UploadLayerPart",
254
- };
255
- body = JSON.stringify(serializeAws_json1_1UploadLayerPartRequest(input, context));
256
- return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
257
- });
258
- }); };
259
- export var deserializeAws_json1_1BatchCheckLayerAvailabilityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
260
- var data, contents, response;
261
- return __generator(this, function (_a) {
262
- switch (_a.label) {
263
- case 0:
264
- if (output.statusCode >= 300) {
265
- return [2, deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError(output, context)];
266
- }
267
- return [4, parseBody(output.body, context)];
268
- case 1:
269
- data = _a.sent();
270
- contents = {};
271
- contents = deserializeAws_json1_1BatchCheckLayerAvailabilityResponse(data, context);
272
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
273
- return [2, Promise.resolve(response)];
274
- }
275
- });
276
- }); };
277
- var deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
278
- var parsedOutput, _a, errorCode, _b, parsedBody;
279
- var _c;
280
- return __generator(this, function (_d) {
281
- switch (_d.label) {
282
- case 0:
283
- _a = [__assign({}, output)];
284
- _c = {};
285
- return [4, parseErrorBody(output.body, context)];
286
- case 1:
287
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
288
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
289
- _b = errorCode;
290
- switch (_b) {
291
- case "InvalidParameterException": return [3, 2];
292
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
293
- case "RegistryNotFoundException": return [3, 4];
294
- case "com.amazonaws.ecrpublic#RegistryNotFoundException": return [3, 4];
295
- case "RepositoryNotFoundException": return [3, 6];
296
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
297
- case "ServerException": return [3, 8];
298
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
299
- }
300
- return [3, 10];
301
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
302
- case 3: throw _d.sent();
303
- case 4: return [4, deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context)];
304
- case 5: throw _d.sent();
305
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
306
- case 7: throw _d.sent();
307
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
308
- case 9: throw _d.sent();
309
- case 10:
310
- parsedBody = parsedOutput.body;
311
- throwDefaultError({
312
- output: output,
313
- parsedBody: parsedBody,
314
- exceptionCtor: __BaseException,
315
- errorCode: errorCode,
316
- });
317
- _d.label = 11;
318
- case 11: return [2];
319
- }
320
- });
321
- }); };
322
- export var deserializeAws_json1_1BatchDeleteImageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
323
- var data, contents, response;
324
- return __generator(this, function (_a) {
325
- switch (_a.label) {
326
- case 0:
327
- if (output.statusCode >= 300) {
328
- return [2, deserializeAws_json1_1BatchDeleteImageCommandError(output, context)];
329
- }
330
- return [4, parseBody(output.body, context)];
331
- case 1:
332
- data = _a.sent();
333
- contents = {};
334
- contents = deserializeAws_json1_1BatchDeleteImageResponse(data, context);
335
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
336
- return [2, Promise.resolve(response)];
337
- }
338
- });
339
- }); };
340
- var deserializeAws_json1_1BatchDeleteImageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
341
- var parsedOutput, _a, errorCode, _b, parsedBody;
342
- var _c;
343
- return __generator(this, function (_d) {
344
- switch (_d.label) {
345
- case 0:
346
- _a = [__assign({}, output)];
347
- _c = {};
348
- return [4, parseErrorBody(output.body, context)];
349
- case 1:
350
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
351
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
352
- _b = errorCode;
353
- switch (_b) {
354
- case "InvalidParameterException": return [3, 2];
355
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
356
- case "RepositoryNotFoundException": return [3, 4];
357
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
358
- case "ServerException": return [3, 6];
359
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
360
- }
361
- return [3, 8];
362
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
363
- case 3: throw _d.sent();
364
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
365
- case 5: throw _d.sent();
366
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
367
- case 7: throw _d.sent();
368
- case 8:
369
- parsedBody = parsedOutput.body;
370
- throwDefaultError({
371
- output: output,
372
- parsedBody: parsedBody,
373
- exceptionCtor: __BaseException,
374
- errorCode: errorCode,
375
- });
376
- _d.label = 9;
377
- case 9: return [2];
378
- }
379
- });
380
- }); };
381
- export var deserializeAws_json1_1CompleteLayerUploadCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
382
- var data, contents, response;
383
- return __generator(this, function (_a) {
384
- switch (_a.label) {
385
- case 0:
386
- if (output.statusCode >= 300) {
387
- return [2, deserializeAws_json1_1CompleteLayerUploadCommandError(output, context)];
388
- }
389
- return [4, parseBody(output.body, context)];
390
- case 1:
391
- data = _a.sent();
392
- contents = {};
393
- contents = deserializeAws_json1_1CompleteLayerUploadResponse(data, context);
394
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
395
- return [2, Promise.resolve(response)];
396
- }
397
- });
398
- }); };
399
- var deserializeAws_json1_1CompleteLayerUploadCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
400
- var parsedOutput, _a, errorCode, _b, parsedBody;
401
- var _c;
402
- return __generator(this, function (_d) {
403
- switch (_d.label) {
404
- case 0:
405
- _a = [__assign({}, output)];
406
- _c = {};
407
- return [4, parseErrorBody(output.body, context)];
408
- case 1:
409
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
410
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
411
- _b = errorCode;
412
- switch (_b) {
413
- case "EmptyUploadException": return [3, 2];
414
- case "com.amazonaws.ecrpublic#EmptyUploadException": return [3, 2];
415
- case "InvalidLayerException": return [3, 4];
416
- case "com.amazonaws.ecrpublic#InvalidLayerException": return [3, 4];
417
- case "InvalidParameterException": return [3, 6];
418
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 6];
419
- case "LayerAlreadyExistsException": return [3, 8];
420
- case "com.amazonaws.ecrpublic#LayerAlreadyExistsException": return [3, 8];
421
- case "LayerPartTooSmallException": return [3, 10];
422
- case "com.amazonaws.ecrpublic#LayerPartTooSmallException": return [3, 10];
423
- case "RegistryNotFoundException": return [3, 12];
424
- case "com.amazonaws.ecrpublic#RegistryNotFoundException": return [3, 12];
425
- case "RepositoryNotFoundException": return [3, 14];
426
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 14];
427
- case "ServerException": return [3, 16];
428
- case "com.amazonaws.ecrpublic#ServerException": return [3, 16];
429
- case "UnsupportedCommandException": return [3, 18];
430
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 18];
431
- case "UploadNotFoundException": return [3, 20];
432
- case "com.amazonaws.ecrpublic#UploadNotFoundException": return [3, 20];
433
- }
434
- return [3, 22];
435
- case 2: return [4, deserializeAws_json1_1EmptyUploadExceptionResponse(parsedOutput, context)];
436
- case 3: throw _d.sent();
437
- case 4: return [4, deserializeAws_json1_1InvalidLayerExceptionResponse(parsedOutput, context)];
438
- case 5: throw _d.sent();
439
- case 6: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
440
- case 7: throw _d.sent();
441
- case 8: return [4, deserializeAws_json1_1LayerAlreadyExistsExceptionResponse(parsedOutput, context)];
442
- case 9: throw _d.sent();
443
- case 10: return [4, deserializeAws_json1_1LayerPartTooSmallExceptionResponse(parsedOutput, context)];
444
- case 11: throw _d.sent();
445
- case 12: return [4, deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context)];
446
- case 13: throw _d.sent();
447
- case 14: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
448
- case 15: throw _d.sent();
449
- case 16: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
450
- case 17: throw _d.sent();
451
- case 18: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
452
- case 19: throw _d.sent();
453
- case 20: return [4, deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context)];
454
- case 21: throw _d.sent();
455
- case 22:
456
- parsedBody = parsedOutput.body;
457
- throwDefaultError({
458
- output: output,
459
- parsedBody: parsedBody,
460
- exceptionCtor: __BaseException,
461
- errorCode: errorCode,
462
- });
463
- _d.label = 23;
464
- case 23: return [2];
465
- }
466
- });
467
- }); };
468
- export var deserializeAws_json1_1CreateRepositoryCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
469
- var data, contents, response;
470
- return __generator(this, function (_a) {
471
- switch (_a.label) {
472
- case 0:
473
- if (output.statusCode >= 300) {
474
- return [2, deserializeAws_json1_1CreateRepositoryCommandError(output, context)];
475
- }
476
- return [4, parseBody(output.body, context)];
477
- case 1:
478
- data = _a.sent();
479
- contents = {};
480
- contents = deserializeAws_json1_1CreateRepositoryResponse(data, context);
481
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
482
- return [2, Promise.resolve(response)];
483
- }
484
- });
485
- }); };
486
- var deserializeAws_json1_1CreateRepositoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
487
- var parsedOutput, _a, errorCode, _b, parsedBody;
488
- var _c;
489
- return __generator(this, function (_d) {
490
- switch (_d.label) {
491
- case 0:
492
- _a = [__assign({}, output)];
493
- _c = {};
494
- return [4, parseErrorBody(output.body, context)];
495
- case 1:
496
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
497
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
498
- _b = errorCode;
499
- switch (_b) {
500
- case "InvalidParameterException": return [3, 2];
501
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
502
- case "InvalidTagParameterException": return [3, 4];
503
- case "com.amazonaws.ecrpublic#InvalidTagParameterException": return [3, 4];
504
- case "LimitExceededException": return [3, 6];
505
- case "com.amazonaws.ecrpublic#LimitExceededException": return [3, 6];
506
- case "RepositoryAlreadyExistsException": return [3, 8];
507
- case "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException": return [3, 8];
508
- case "ServerException": return [3, 10];
509
- case "com.amazonaws.ecrpublic#ServerException": return [3, 10];
510
- case "TooManyTagsException": return [3, 12];
511
- case "com.amazonaws.ecrpublic#TooManyTagsException": return [3, 12];
512
- }
513
- return [3, 14];
514
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
515
- case 3: throw _d.sent();
516
- case 4: return [4, deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context)];
517
- case 5: throw _d.sent();
518
- case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
519
- case 7: throw _d.sent();
520
- case 8: return [4, deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse(parsedOutput, context)];
521
- case 9: throw _d.sent();
522
- case 10: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
523
- case 11: throw _d.sent();
524
- case 12: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
525
- case 13: throw _d.sent();
526
- case 14:
527
- parsedBody = parsedOutput.body;
528
- throwDefaultError({
529
- output: output,
530
- parsedBody: parsedBody,
531
- exceptionCtor: __BaseException,
532
- errorCode: errorCode,
533
- });
534
- _d.label = 15;
535
- case 15: return [2];
536
- }
537
- });
538
- }); };
539
- export var deserializeAws_json1_1DeleteRepositoryCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
540
- var data, contents, response;
541
- return __generator(this, function (_a) {
542
- switch (_a.label) {
543
- case 0:
544
- if (output.statusCode >= 300) {
545
- return [2, deserializeAws_json1_1DeleteRepositoryCommandError(output, context)];
546
- }
547
- return [4, parseBody(output.body, context)];
548
- case 1:
549
- data = _a.sent();
550
- contents = {};
551
- contents = deserializeAws_json1_1DeleteRepositoryResponse(data, context);
552
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
553
- return [2, Promise.resolve(response)];
554
- }
555
- });
556
- }); };
557
- var deserializeAws_json1_1DeleteRepositoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
558
- var parsedOutput, _a, errorCode, _b, parsedBody;
559
- var _c;
560
- return __generator(this, function (_d) {
561
- switch (_d.label) {
562
- case 0:
563
- _a = [__assign({}, output)];
564
- _c = {};
565
- return [4, parseErrorBody(output.body, context)];
566
- case 1:
567
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
568
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
569
- _b = errorCode;
570
- switch (_b) {
571
- case "InvalidParameterException": return [3, 2];
572
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
573
- case "RepositoryNotEmptyException": return [3, 4];
574
- case "com.amazonaws.ecrpublic#RepositoryNotEmptyException": return [3, 4];
575
- case "RepositoryNotFoundException": return [3, 6];
576
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
577
- case "ServerException": return [3, 8];
578
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
579
- }
580
- return [3, 10];
581
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
582
- case 3: throw _d.sent();
583
- case 4: return [4, deserializeAws_json1_1RepositoryNotEmptyExceptionResponse(parsedOutput, context)];
584
- case 5: throw _d.sent();
585
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
586
- case 7: throw _d.sent();
587
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
588
- case 9: throw _d.sent();
589
- case 10:
590
- parsedBody = parsedOutput.body;
591
- throwDefaultError({
592
- output: output,
593
- parsedBody: parsedBody,
594
- exceptionCtor: __BaseException,
595
- errorCode: errorCode,
596
- });
597
- _d.label = 11;
598
- case 11: return [2];
599
- }
600
- });
601
- }); };
602
- export var deserializeAws_json1_1DeleteRepositoryPolicyCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
603
- var data, contents, response;
604
- return __generator(this, function (_a) {
605
- switch (_a.label) {
606
- case 0:
607
- if (output.statusCode >= 300) {
608
- return [2, deserializeAws_json1_1DeleteRepositoryPolicyCommandError(output, context)];
609
- }
610
- return [4, parseBody(output.body, context)];
611
- case 1:
612
- data = _a.sent();
613
- contents = {};
614
- contents = deserializeAws_json1_1DeleteRepositoryPolicyResponse(data, context);
615
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
616
- return [2, Promise.resolve(response)];
617
- }
618
- });
619
- }); };
620
- var deserializeAws_json1_1DeleteRepositoryPolicyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
621
- var parsedOutput, _a, errorCode, _b, parsedBody;
622
- var _c;
623
- return __generator(this, function (_d) {
624
- switch (_d.label) {
625
- case 0:
626
- _a = [__assign({}, output)];
627
- _c = {};
628
- return [4, parseErrorBody(output.body, context)];
629
- case 1:
630
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
631
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
632
- _b = errorCode;
633
- switch (_b) {
634
- case "InvalidParameterException": return [3, 2];
635
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
636
- case "RepositoryNotFoundException": return [3, 4];
637
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
638
- case "RepositoryPolicyNotFoundException": return [3, 6];
639
- case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException": return [3, 6];
640
- case "ServerException": return [3, 8];
641
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
642
- }
643
- return [3, 10];
644
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
645
- case 3: throw _d.sent();
646
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
647
- case 5: throw _d.sent();
648
- case 6: return [4, deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context)];
649
- case 7: throw _d.sent();
650
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
651
- case 9: throw _d.sent();
652
- case 10:
653
- parsedBody = parsedOutput.body;
654
- throwDefaultError({
655
- output: output,
656
- parsedBody: parsedBody,
657
- exceptionCtor: __BaseException,
658
- errorCode: errorCode,
659
- });
660
- _d.label = 11;
661
- case 11: return [2];
662
- }
663
- });
664
- }); };
665
- export var deserializeAws_json1_1DescribeImagesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
666
- var data, contents, response;
667
- return __generator(this, function (_a) {
668
- switch (_a.label) {
669
- case 0:
670
- if (output.statusCode >= 300) {
671
- return [2, deserializeAws_json1_1DescribeImagesCommandError(output, context)];
672
- }
673
- return [4, parseBody(output.body, context)];
674
- case 1:
675
- data = _a.sent();
676
- contents = {};
677
- contents = deserializeAws_json1_1DescribeImagesResponse(data, context);
678
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
679
- return [2, Promise.resolve(response)];
680
- }
681
- });
682
- }); };
683
- var deserializeAws_json1_1DescribeImagesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
684
- var parsedOutput, _a, errorCode, _b, parsedBody;
685
- var _c;
686
- return __generator(this, function (_d) {
687
- switch (_d.label) {
688
- case 0:
689
- _a = [__assign({}, output)];
690
- _c = {};
691
- return [4, parseErrorBody(output.body, context)];
692
- case 1:
693
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
694
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
695
- _b = errorCode;
696
- switch (_b) {
697
- case "ImageNotFoundException": return [3, 2];
698
- case "com.amazonaws.ecrpublic#ImageNotFoundException": return [3, 2];
699
- case "InvalidParameterException": return [3, 4];
700
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 4];
701
- case "RepositoryNotFoundException": return [3, 6];
702
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
703
- case "ServerException": return [3, 8];
704
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
705
- }
706
- return [3, 10];
707
- case 2: return [4, deserializeAws_json1_1ImageNotFoundExceptionResponse(parsedOutput, context)];
708
- case 3: throw _d.sent();
709
- case 4: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
710
- case 5: throw _d.sent();
711
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
712
- case 7: throw _d.sent();
713
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
714
- case 9: throw _d.sent();
715
- case 10:
716
- parsedBody = parsedOutput.body;
717
- throwDefaultError({
718
- output: output,
719
- parsedBody: parsedBody,
720
- exceptionCtor: __BaseException,
721
- errorCode: errorCode,
722
- });
723
- _d.label = 11;
724
- case 11: return [2];
725
- }
726
- });
727
- }); };
728
- export var deserializeAws_json1_1DescribeImageTagsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
729
- var data, contents, response;
730
- return __generator(this, function (_a) {
731
- switch (_a.label) {
732
- case 0:
733
- if (output.statusCode >= 300) {
734
- return [2, deserializeAws_json1_1DescribeImageTagsCommandError(output, context)];
735
- }
736
- return [4, parseBody(output.body, context)];
737
- case 1:
738
- data = _a.sent();
739
- contents = {};
740
- contents = deserializeAws_json1_1DescribeImageTagsResponse(data, context);
741
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
742
- return [2, Promise.resolve(response)];
743
- }
744
- });
745
- }); };
746
- var deserializeAws_json1_1DescribeImageTagsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
747
- var parsedOutput, _a, errorCode, _b, parsedBody;
748
- var _c;
749
- return __generator(this, function (_d) {
750
- switch (_d.label) {
751
- case 0:
752
- _a = [__assign({}, output)];
753
- _c = {};
754
- return [4, parseErrorBody(output.body, context)];
755
- case 1:
756
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
757
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
758
- _b = errorCode;
759
- switch (_b) {
760
- case "InvalidParameterException": return [3, 2];
761
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
762
- case "RepositoryNotFoundException": return [3, 4];
763
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
764
- case "ServerException": return [3, 6];
765
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
766
- }
767
- return [3, 8];
768
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
769
- case 3: throw _d.sent();
770
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
771
- case 5: throw _d.sent();
772
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
773
- case 7: throw _d.sent();
774
- case 8:
775
- parsedBody = parsedOutput.body;
776
- throwDefaultError({
777
- output: output,
778
- parsedBody: parsedBody,
779
- exceptionCtor: __BaseException,
780
- errorCode: errorCode,
781
- });
782
- _d.label = 9;
783
- case 9: return [2];
784
- }
785
- });
786
- }); };
787
- export var deserializeAws_json1_1DescribeRegistriesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
788
- var data, contents, response;
789
- return __generator(this, function (_a) {
790
- switch (_a.label) {
791
- case 0:
792
- if (output.statusCode >= 300) {
793
- return [2, deserializeAws_json1_1DescribeRegistriesCommandError(output, context)];
794
- }
795
- return [4, parseBody(output.body, context)];
796
- case 1:
797
- data = _a.sent();
798
- contents = {};
799
- contents = deserializeAws_json1_1DescribeRegistriesResponse(data, context);
800
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
801
- return [2, Promise.resolve(response)];
802
- }
803
- });
804
- }); };
805
- var deserializeAws_json1_1DescribeRegistriesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
806
- var parsedOutput, _a, errorCode, _b, parsedBody;
807
- var _c;
808
- return __generator(this, function (_d) {
809
- switch (_d.label) {
810
- case 0:
811
- _a = [__assign({}, output)];
812
- _c = {};
813
- return [4, parseErrorBody(output.body, context)];
814
- case 1:
815
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
816
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
817
- _b = errorCode;
818
- switch (_b) {
819
- case "InvalidParameterException": return [3, 2];
820
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
821
- case "ServerException": return [3, 4];
822
- case "com.amazonaws.ecrpublic#ServerException": return [3, 4];
823
- case "UnsupportedCommandException": return [3, 6];
824
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 6];
825
- }
826
- return [3, 8];
827
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
828
- case 3: throw _d.sent();
829
- case 4: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
830
- case 5: throw _d.sent();
831
- case 6: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
832
- case 7: throw _d.sent();
833
- case 8:
834
- parsedBody = parsedOutput.body;
835
- throwDefaultError({
836
- output: output,
837
- parsedBody: parsedBody,
838
- exceptionCtor: __BaseException,
839
- errorCode: errorCode,
840
- });
841
- _d.label = 9;
842
- case 9: return [2];
843
- }
844
- });
845
- }); };
846
- export var deserializeAws_json1_1DescribeRepositoriesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
847
- var data, contents, response;
848
- return __generator(this, function (_a) {
849
- switch (_a.label) {
850
- case 0:
851
- if (output.statusCode >= 300) {
852
- return [2, deserializeAws_json1_1DescribeRepositoriesCommandError(output, context)];
853
- }
854
- return [4, parseBody(output.body, context)];
855
- case 1:
856
- data = _a.sent();
857
- contents = {};
858
- contents = deserializeAws_json1_1DescribeRepositoriesResponse(data, context);
859
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
860
- return [2, Promise.resolve(response)];
861
- }
862
- });
863
- }); };
864
- var deserializeAws_json1_1DescribeRepositoriesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
865
- var parsedOutput, _a, errorCode, _b, parsedBody;
866
- var _c;
867
- return __generator(this, function (_d) {
868
- switch (_d.label) {
869
- case 0:
870
- _a = [__assign({}, output)];
871
- _c = {};
872
- return [4, parseErrorBody(output.body, context)];
873
- case 1:
874
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
875
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
876
- _b = errorCode;
877
- switch (_b) {
878
- case "InvalidParameterException": return [3, 2];
879
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
880
- case "RepositoryNotFoundException": return [3, 4];
881
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
882
- case "ServerException": return [3, 6];
883
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
884
- }
885
- return [3, 8];
886
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
887
- case 3: throw _d.sent();
888
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
889
- case 5: throw _d.sent();
890
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
891
- case 7: throw _d.sent();
892
- case 8:
893
- parsedBody = parsedOutput.body;
894
- throwDefaultError({
895
- output: output,
896
- parsedBody: parsedBody,
897
- exceptionCtor: __BaseException,
898
- errorCode: errorCode,
899
- });
900
- _d.label = 9;
901
- case 9: return [2];
902
- }
903
- });
904
- }); };
905
- export var deserializeAws_json1_1GetAuthorizationTokenCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
906
- var data, contents, response;
907
- return __generator(this, function (_a) {
908
- switch (_a.label) {
909
- case 0:
910
- if (output.statusCode >= 300) {
911
- return [2, deserializeAws_json1_1GetAuthorizationTokenCommandError(output, context)];
912
- }
913
- return [4, parseBody(output.body, context)];
914
- case 1:
915
- data = _a.sent();
916
- contents = {};
917
- contents = deserializeAws_json1_1GetAuthorizationTokenResponse(data, context);
918
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
919
- return [2, Promise.resolve(response)];
920
- }
921
- });
922
- }); };
923
- var deserializeAws_json1_1GetAuthorizationTokenCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
924
- var parsedOutput, _a, errorCode, _b, parsedBody;
925
- var _c;
926
- return __generator(this, function (_d) {
927
- switch (_d.label) {
928
- case 0:
929
- _a = [__assign({}, output)];
930
- _c = {};
931
- return [4, parseErrorBody(output.body, context)];
932
- case 1:
933
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
934
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
935
- _b = errorCode;
936
- switch (_b) {
937
- case "InvalidParameterException": return [3, 2];
938
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
939
- case "ServerException": return [3, 4];
940
- case "com.amazonaws.ecrpublic#ServerException": return [3, 4];
941
- }
942
- return [3, 6];
943
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
944
- case 3: throw _d.sent();
945
- case 4: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
946
- case 5: throw _d.sent();
947
- case 6:
948
- parsedBody = parsedOutput.body;
949
- throwDefaultError({
950
- output: output,
951
- parsedBody: parsedBody,
952
- exceptionCtor: __BaseException,
953
- errorCode: errorCode,
954
- });
955
- _d.label = 7;
956
- case 7: return [2];
957
- }
958
- });
959
- }); };
960
- export var deserializeAws_json1_1GetRegistryCatalogDataCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
961
- var data, contents, response;
962
- return __generator(this, function (_a) {
963
- switch (_a.label) {
964
- case 0:
965
- if (output.statusCode >= 300) {
966
- return [2, deserializeAws_json1_1GetRegistryCatalogDataCommandError(output, context)];
967
- }
968
- return [4, parseBody(output.body, context)];
969
- case 1:
970
- data = _a.sent();
971
- contents = {};
972
- contents = deserializeAws_json1_1GetRegistryCatalogDataResponse(data, context);
973
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
974
- return [2, Promise.resolve(response)];
975
- }
976
- });
977
- }); };
978
- var deserializeAws_json1_1GetRegistryCatalogDataCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
979
- var parsedOutput, _a, errorCode, _b, parsedBody;
980
- var _c;
981
- return __generator(this, function (_d) {
982
- switch (_d.label) {
983
- case 0:
984
- _a = [__assign({}, output)];
985
- _c = {};
986
- return [4, parseErrorBody(output.body, context)];
987
- case 1:
988
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
989
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
990
- _b = errorCode;
991
- switch (_b) {
992
- case "ServerException": return [3, 2];
993
- case "com.amazonaws.ecrpublic#ServerException": return [3, 2];
994
- case "UnsupportedCommandException": return [3, 4];
995
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 4];
996
- }
997
- return [3, 6];
998
- case 2: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
999
- case 3: throw _d.sent();
1000
- case 4: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
1001
- case 5: throw _d.sent();
1002
- case 6:
1003
- parsedBody = parsedOutput.body;
1004
- throwDefaultError({
1005
- output: output,
1006
- parsedBody: parsedBody,
1007
- exceptionCtor: __BaseException,
1008
- errorCode: errorCode,
1009
- });
1010
- _d.label = 7;
1011
- case 7: return [2];
1012
- }
1013
- });
1014
- }); };
1015
- export var deserializeAws_json1_1GetRepositoryCatalogDataCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1016
- var data, contents, response;
1017
- return __generator(this, function (_a) {
1018
- switch (_a.label) {
1019
- case 0:
1020
- if (output.statusCode >= 300) {
1021
- return [2, deserializeAws_json1_1GetRepositoryCatalogDataCommandError(output, context)];
1022
- }
1023
- return [4, parseBody(output.body, context)];
1024
- case 1:
1025
- data = _a.sent();
1026
- contents = {};
1027
- contents = deserializeAws_json1_1GetRepositoryCatalogDataResponse(data, context);
1028
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1029
- return [2, Promise.resolve(response)];
1030
- }
1031
- });
1032
- }); };
1033
- var deserializeAws_json1_1GetRepositoryCatalogDataCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1034
- var parsedOutput, _a, errorCode, _b, parsedBody;
1035
- var _c;
1036
- return __generator(this, function (_d) {
1037
- switch (_d.label) {
1038
- case 0:
1039
- _a = [__assign({}, output)];
1040
- _c = {};
1041
- return [4, parseErrorBody(output.body, context)];
1042
- case 1:
1043
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1044
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1045
- _b = errorCode;
1046
- switch (_b) {
1047
- case "InvalidParameterException": return [3, 2];
1048
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1049
- case "RepositoryNotFoundException": return [3, 4];
1050
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
1051
- case "ServerException": return [3, 6];
1052
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
1053
- }
1054
- return [3, 8];
1055
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1056
- case 3: throw _d.sent();
1057
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1058
- case 5: throw _d.sent();
1059
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1060
- case 7: throw _d.sent();
1061
- case 8:
1062
- parsedBody = parsedOutput.body;
1063
- throwDefaultError({
1064
- output: output,
1065
- parsedBody: parsedBody,
1066
- exceptionCtor: __BaseException,
1067
- errorCode: errorCode,
1068
- });
1069
- _d.label = 9;
1070
- case 9: return [2];
1071
- }
1072
- });
1073
- }); };
1074
- export var deserializeAws_json1_1GetRepositoryPolicyCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1075
- var data, contents, response;
1076
- return __generator(this, function (_a) {
1077
- switch (_a.label) {
1078
- case 0:
1079
- if (output.statusCode >= 300) {
1080
- return [2, deserializeAws_json1_1GetRepositoryPolicyCommandError(output, context)];
1081
- }
1082
- return [4, parseBody(output.body, context)];
1083
- case 1:
1084
- data = _a.sent();
1085
- contents = {};
1086
- contents = deserializeAws_json1_1GetRepositoryPolicyResponse(data, context);
1087
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1088
- return [2, Promise.resolve(response)];
1089
- }
1090
- });
1091
- }); };
1092
- var deserializeAws_json1_1GetRepositoryPolicyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1093
- var parsedOutput, _a, errorCode, _b, parsedBody;
1094
- var _c;
1095
- return __generator(this, function (_d) {
1096
- switch (_d.label) {
1097
- case 0:
1098
- _a = [__assign({}, output)];
1099
- _c = {};
1100
- return [4, parseErrorBody(output.body, context)];
1101
- case 1:
1102
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1103
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1104
- _b = errorCode;
1105
- switch (_b) {
1106
- case "InvalidParameterException": return [3, 2];
1107
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1108
- case "RepositoryNotFoundException": return [3, 4];
1109
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
1110
- case "RepositoryPolicyNotFoundException": return [3, 6];
1111
- case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException": return [3, 6];
1112
- case "ServerException": return [3, 8];
1113
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
1114
- }
1115
- return [3, 10];
1116
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1117
- case 3: throw _d.sent();
1118
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1119
- case 5: throw _d.sent();
1120
- case 6: return [4, deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context)];
1121
- case 7: throw _d.sent();
1122
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1123
- case 9: throw _d.sent();
1124
- case 10:
1125
- parsedBody = parsedOutput.body;
1126
- throwDefaultError({
1127
- output: output,
1128
- parsedBody: parsedBody,
1129
- exceptionCtor: __BaseException,
1130
- errorCode: errorCode,
1131
- });
1132
- _d.label = 11;
1133
- case 11: return [2];
1134
- }
1135
- });
1136
- }); };
1137
- export var deserializeAws_json1_1InitiateLayerUploadCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1138
- var data, contents, response;
1139
- return __generator(this, function (_a) {
1140
- switch (_a.label) {
1141
- case 0:
1142
- if (output.statusCode >= 300) {
1143
- return [2, deserializeAws_json1_1InitiateLayerUploadCommandError(output, context)];
1144
- }
1145
- return [4, parseBody(output.body, context)];
1146
- case 1:
1147
- data = _a.sent();
1148
- contents = {};
1149
- contents = deserializeAws_json1_1InitiateLayerUploadResponse(data, context);
1150
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1151
- return [2, Promise.resolve(response)];
1152
- }
1153
- });
1154
- }); };
1155
- var deserializeAws_json1_1InitiateLayerUploadCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1156
- var parsedOutput, _a, errorCode, _b, parsedBody;
1157
- var _c;
1158
- return __generator(this, function (_d) {
1159
- switch (_d.label) {
1160
- case 0:
1161
- _a = [__assign({}, output)];
1162
- _c = {};
1163
- return [4, parseErrorBody(output.body, context)];
1164
- case 1:
1165
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1166
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1167
- _b = errorCode;
1168
- switch (_b) {
1169
- case "InvalidParameterException": return [3, 2];
1170
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1171
- case "RegistryNotFoundException": return [3, 4];
1172
- case "com.amazonaws.ecrpublic#RegistryNotFoundException": return [3, 4];
1173
- case "RepositoryNotFoundException": return [3, 6];
1174
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
1175
- case "ServerException": return [3, 8];
1176
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
1177
- case "UnsupportedCommandException": return [3, 10];
1178
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 10];
1179
- }
1180
- return [3, 12];
1181
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1182
- case 3: throw _d.sent();
1183
- case 4: return [4, deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context)];
1184
- case 5: throw _d.sent();
1185
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1186
- case 7: throw _d.sent();
1187
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1188
- case 9: throw _d.sent();
1189
- case 10: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
1190
- case 11: throw _d.sent();
1191
- case 12:
1192
- parsedBody = parsedOutput.body;
1193
- throwDefaultError({
1194
- output: output,
1195
- parsedBody: parsedBody,
1196
- exceptionCtor: __BaseException,
1197
- errorCode: errorCode,
1198
- });
1199
- _d.label = 13;
1200
- case 13: return [2];
1201
- }
1202
- });
1203
- }); };
1204
- export var deserializeAws_json1_1ListTagsForResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1205
- var data, contents, response;
1206
- return __generator(this, function (_a) {
1207
- switch (_a.label) {
1208
- case 0:
1209
- if (output.statusCode >= 300) {
1210
- return [2, deserializeAws_json1_1ListTagsForResourceCommandError(output, context)];
1211
- }
1212
- return [4, parseBody(output.body, context)];
1213
- case 1:
1214
- data = _a.sent();
1215
- contents = {};
1216
- contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
1217
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1218
- return [2, Promise.resolve(response)];
1219
- }
1220
- });
1221
- }); };
1222
- var deserializeAws_json1_1ListTagsForResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1223
- var parsedOutput, _a, errorCode, _b, parsedBody;
1224
- var _c;
1225
- return __generator(this, function (_d) {
1226
- switch (_d.label) {
1227
- case 0:
1228
- _a = [__assign({}, output)];
1229
- _c = {};
1230
- return [4, parseErrorBody(output.body, context)];
1231
- case 1:
1232
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1233
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1234
- _b = errorCode;
1235
- switch (_b) {
1236
- case "InvalidParameterException": return [3, 2];
1237
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1238
- case "RepositoryNotFoundException": return [3, 4];
1239
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
1240
- case "ServerException": return [3, 6];
1241
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
1242
- }
1243
- return [3, 8];
1244
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1245
- case 3: throw _d.sent();
1246
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1247
- case 5: throw _d.sent();
1248
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1249
- case 7: throw _d.sent();
1250
- case 8:
1251
- parsedBody = parsedOutput.body;
1252
- throwDefaultError({
1253
- output: output,
1254
- parsedBody: parsedBody,
1255
- exceptionCtor: __BaseException,
1256
- errorCode: errorCode,
1257
- });
1258
- _d.label = 9;
1259
- case 9: return [2];
1260
- }
1261
- });
1262
- }); };
1263
- export var deserializeAws_json1_1PutImageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1264
- var data, contents, response;
1265
- return __generator(this, function (_a) {
1266
- switch (_a.label) {
1267
- case 0:
1268
- if (output.statusCode >= 300) {
1269
- return [2, deserializeAws_json1_1PutImageCommandError(output, context)];
1270
- }
1271
- return [4, parseBody(output.body, context)];
1272
- case 1:
1273
- data = _a.sent();
1274
- contents = {};
1275
- contents = deserializeAws_json1_1PutImageResponse(data, context);
1276
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1277
- return [2, Promise.resolve(response)];
1278
- }
1279
- });
1280
- }); };
1281
- var deserializeAws_json1_1PutImageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1282
- var parsedOutput, _a, errorCode, _b, parsedBody;
1283
- var _c;
1284
- return __generator(this, function (_d) {
1285
- switch (_d.label) {
1286
- case 0:
1287
- _a = [__assign({}, output)];
1288
- _c = {};
1289
- return [4, parseErrorBody(output.body, context)];
1290
- case 1:
1291
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1292
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1293
- _b = errorCode;
1294
- switch (_b) {
1295
- case "ImageAlreadyExistsException": return [3, 2];
1296
- case "com.amazonaws.ecrpublic#ImageAlreadyExistsException": return [3, 2];
1297
- case "ImageDigestDoesNotMatchException": return [3, 4];
1298
- case "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException": return [3, 4];
1299
- case "ImageTagAlreadyExistsException": return [3, 6];
1300
- case "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException": return [3, 6];
1301
- case "InvalidParameterException": return [3, 8];
1302
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 8];
1303
- case "LayersNotFoundException": return [3, 10];
1304
- case "com.amazonaws.ecrpublic#LayersNotFoundException": return [3, 10];
1305
- case "LimitExceededException": return [3, 12];
1306
- case "com.amazonaws.ecrpublic#LimitExceededException": return [3, 12];
1307
- case "ReferencedImagesNotFoundException": return [3, 14];
1308
- case "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException": return [3, 14];
1309
- case "RegistryNotFoundException": return [3, 16];
1310
- case "com.amazonaws.ecrpublic#RegistryNotFoundException": return [3, 16];
1311
- case "RepositoryNotFoundException": return [3, 18];
1312
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 18];
1313
- case "ServerException": return [3, 20];
1314
- case "com.amazonaws.ecrpublic#ServerException": return [3, 20];
1315
- case "UnsupportedCommandException": return [3, 22];
1316
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 22];
1317
- }
1318
- return [3, 24];
1319
- case 2: return [4, deserializeAws_json1_1ImageAlreadyExistsExceptionResponse(parsedOutput, context)];
1320
- case 3: throw _d.sent();
1321
- case 4: return [4, deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse(parsedOutput, context)];
1322
- case 5: throw _d.sent();
1323
- case 6: return [4, deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse(parsedOutput, context)];
1324
- case 7: throw _d.sent();
1325
- case 8: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1326
- case 9: throw _d.sent();
1327
- case 10: return [4, deserializeAws_json1_1LayersNotFoundExceptionResponse(parsedOutput, context)];
1328
- case 11: throw _d.sent();
1329
- case 12: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1330
- case 13: throw _d.sent();
1331
- case 14: return [4, deserializeAws_json1_1ReferencedImagesNotFoundExceptionResponse(parsedOutput, context)];
1332
- case 15: throw _d.sent();
1333
- case 16: return [4, deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context)];
1334
- case 17: throw _d.sent();
1335
- case 18: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1336
- case 19: throw _d.sent();
1337
- case 20: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1338
- case 21: throw _d.sent();
1339
- case 22: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
1340
- case 23: throw _d.sent();
1341
- case 24:
1342
- parsedBody = parsedOutput.body;
1343
- throwDefaultError({
1344
- output: output,
1345
- parsedBody: parsedBody,
1346
- exceptionCtor: __BaseException,
1347
- errorCode: errorCode,
1348
- });
1349
- _d.label = 25;
1350
- case 25: return [2];
1351
- }
1352
- });
1353
- }); };
1354
- export var deserializeAws_json1_1PutRegistryCatalogDataCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1355
- var data, contents, response;
1356
- return __generator(this, function (_a) {
1357
- switch (_a.label) {
1358
- case 0:
1359
- if (output.statusCode >= 300) {
1360
- return [2, deserializeAws_json1_1PutRegistryCatalogDataCommandError(output, context)];
1361
- }
1362
- return [4, parseBody(output.body, context)];
1363
- case 1:
1364
- data = _a.sent();
1365
- contents = {};
1366
- contents = deserializeAws_json1_1PutRegistryCatalogDataResponse(data, context);
1367
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1368
- return [2, Promise.resolve(response)];
1369
- }
1370
- });
1371
- }); };
1372
- var deserializeAws_json1_1PutRegistryCatalogDataCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1373
- var parsedOutput, _a, errorCode, _b, parsedBody;
1374
- var _c;
1375
- return __generator(this, function (_d) {
1376
- switch (_d.label) {
1377
- case 0:
1378
- _a = [__assign({}, output)];
1379
- _c = {};
1380
- return [4, parseErrorBody(output.body, context)];
1381
- case 1:
1382
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1383
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1384
- _b = errorCode;
1385
- switch (_b) {
1386
- case "InvalidParameterException": return [3, 2];
1387
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1388
- case "ServerException": return [3, 4];
1389
- case "com.amazonaws.ecrpublic#ServerException": return [3, 4];
1390
- case "UnsupportedCommandException": return [3, 6];
1391
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 6];
1392
- }
1393
- return [3, 8];
1394
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1395
- case 3: throw _d.sent();
1396
- case 4: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1397
- case 5: throw _d.sent();
1398
- case 6: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
1399
- case 7: throw _d.sent();
1400
- case 8:
1401
- parsedBody = parsedOutput.body;
1402
- throwDefaultError({
1403
- output: output,
1404
- parsedBody: parsedBody,
1405
- exceptionCtor: __BaseException,
1406
- errorCode: errorCode,
1407
- });
1408
- _d.label = 9;
1409
- case 9: return [2];
1410
- }
1411
- });
1412
- }); };
1413
- export var deserializeAws_json1_1PutRepositoryCatalogDataCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1414
- var data, contents, response;
1415
- return __generator(this, function (_a) {
1416
- switch (_a.label) {
1417
- case 0:
1418
- if (output.statusCode >= 300) {
1419
- return [2, deserializeAws_json1_1PutRepositoryCatalogDataCommandError(output, context)];
1420
- }
1421
- return [4, parseBody(output.body, context)];
1422
- case 1:
1423
- data = _a.sent();
1424
- contents = {};
1425
- contents = deserializeAws_json1_1PutRepositoryCatalogDataResponse(data, context);
1426
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1427
- return [2, Promise.resolve(response)];
1428
- }
1429
- });
1430
- }); };
1431
- var deserializeAws_json1_1PutRepositoryCatalogDataCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1432
- var parsedOutput, _a, errorCode, _b, parsedBody;
1433
- var _c;
1434
- return __generator(this, function (_d) {
1435
- switch (_d.label) {
1436
- case 0:
1437
- _a = [__assign({}, output)];
1438
- _c = {};
1439
- return [4, parseErrorBody(output.body, context)];
1440
- case 1:
1441
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1442
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1443
- _b = errorCode;
1444
- switch (_b) {
1445
- case "InvalidParameterException": return [3, 2];
1446
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1447
- case "RepositoryNotFoundException": return [3, 4];
1448
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
1449
- case "ServerException": return [3, 6];
1450
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
1451
- }
1452
- return [3, 8];
1453
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1454
- case 3: throw _d.sent();
1455
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1456
- case 5: throw _d.sent();
1457
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1458
- case 7: throw _d.sent();
1459
- case 8:
1460
- parsedBody = parsedOutput.body;
1461
- throwDefaultError({
1462
- output: output,
1463
- parsedBody: parsedBody,
1464
- exceptionCtor: __BaseException,
1465
- errorCode: errorCode,
1466
- });
1467
- _d.label = 9;
1468
- case 9: return [2];
1469
- }
1470
- });
1471
- }); };
1472
- export var deserializeAws_json1_1SetRepositoryPolicyCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1473
- var data, contents, response;
1474
- return __generator(this, function (_a) {
1475
- switch (_a.label) {
1476
- case 0:
1477
- if (output.statusCode >= 300) {
1478
- return [2, deserializeAws_json1_1SetRepositoryPolicyCommandError(output, context)];
1479
- }
1480
- return [4, parseBody(output.body, context)];
1481
- case 1:
1482
- data = _a.sent();
1483
- contents = {};
1484
- contents = deserializeAws_json1_1SetRepositoryPolicyResponse(data, context);
1485
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1486
- return [2, Promise.resolve(response)];
1487
- }
1488
- });
1489
- }); };
1490
- var deserializeAws_json1_1SetRepositoryPolicyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1491
- var parsedOutput, _a, errorCode, _b, parsedBody;
1492
- var _c;
1493
- return __generator(this, function (_d) {
1494
- switch (_d.label) {
1495
- case 0:
1496
- _a = [__assign({}, output)];
1497
- _c = {};
1498
- return [4, parseErrorBody(output.body, context)];
1499
- case 1:
1500
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1501
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1502
- _b = errorCode;
1503
- switch (_b) {
1504
- case "InvalidParameterException": return [3, 2];
1505
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1506
- case "RepositoryNotFoundException": return [3, 4];
1507
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 4];
1508
- case "ServerException": return [3, 6];
1509
- case "com.amazonaws.ecrpublic#ServerException": return [3, 6];
1510
- }
1511
- return [3, 8];
1512
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1513
- case 3: throw _d.sent();
1514
- case 4: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1515
- case 5: throw _d.sent();
1516
- case 6: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1517
- case 7: throw _d.sent();
1518
- case 8:
1519
- parsedBody = parsedOutput.body;
1520
- throwDefaultError({
1521
- output: output,
1522
- parsedBody: parsedBody,
1523
- exceptionCtor: __BaseException,
1524
- errorCode: errorCode,
1525
- });
1526
- _d.label = 9;
1527
- case 9: return [2];
1528
- }
1529
- });
1530
- }); };
1531
- export var deserializeAws_json1_1TagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1532
- var data, contents, response;
1533
- return __generator(this, function (_a) {
1534
- switch (_a.label) {
1535
- case 0:
1536
- if (output.statusCode >= 300) {
1537
- return [2, deserializeAws_json1_1TagResourceCommandError(output, context)];
1538
- }
1539
- return [4, parseBody(output.body, context)];
1540
- case 1:
1541
- data = _a.sent();
1542
- contents = {};
1543
- contents = deserializeAws_json1_1TagResourceResponse(data, context);
1544
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1545
- return [2, Promise.resolve(response)];
1546
- }
1547
- });
1548
- }); };
1549
- var deserializeAws_json1_1TagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1550
- var parsedOutput, _a, errorCode, _b, parsedBody;
1551
- var _c;
1552
- return __generator(this, function (_d) {
1553
- switch (_d.label) {
1554
- case 0:
1555
- _a = [__assign({}, output)];
1556
- _c = {};
1557
- return [4, parseErrorBody(output.body, context)];
1558
- case 1:
1559
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1560
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1561
- _b = errorCode;
1562
- switch (_b) {
1563
- case "InvalidParameterException": return [3, 2];
1564
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1565
- case "InvalidTagParameterException": return [3, 4];
1566
- case "com.amazonaws.ecrpublic#InvalidTagParameterException": return [3, 4];
1567
- case "RepositoryNotFoundException": return [3, 6];
1568
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
1569
- case "ServerException": return [3, 8];
1570
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
1571
- case "TooManyTagsException": return [3, 10];
1572
- case "com.amazonaws.ecrpublic#TooManyTagsException": return [3, 10];
1573
- }
1574
- return [3, 12];
1575
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1576
- case 3: throw _d.sent();
1577
- case 4: return [4, deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context)];
1578
- case 5: throw _d.sent();
1579
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1580
- case 7: throw _d.sent();
1581
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1582
- case 9: throw _d.sent();
1583
- case 10: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
1584
- case 11: throw _d.sent();
1585
- case 12:
1586
- parsedBody = parsedOutput.body;
1587
- throwDefaultError({
1588
- output: output,
1589
- parsedBody: parsedBody,
1590
- exceptionCtor: __BaseException,
1591
- errorCode: errorCode,
1592
- });
1593
- _d.label = 13;
1594
- case 13: return [2];
1595
- }
1596
- });
1597
- }); };
1598
- export var deserializeAws_json1_1UntagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1599
- var data, contents, response;
1600
- return __generator(this, function (_a) {
1601
- switch (_a.label) {
1602
- case 0:
1603
- if (output.statusCode >= 300) {
1604
- return [2, deserializeAws_json1_1UntagResourceCommandError(output, context)];
1605
- }
1606
- return [4, parseBody(output.body, context)];
1607
- case 1:
1608
- data = _a.sent();
1609
- contents = {};
1610
- contents = deserializeAws_json1_1UntagResourceResponse(data, context);
1611
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1612
- return [2, Promise.resolve(response)];
1613
- }
1614
- });
1615
- }); };
1616
- var deserializeAws_json1_1UntagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1617
- var parsedOutput, _a, errorCode, _b, parsedBody;
1618
- var _c;
1619
- return __generator(this, function (_d) {
1620
- switch (_d.label) {
1621
- case 0:
1622
- _a = [__assign({}, output)];
1623
- _c = {};
1624
- return [4, parseErrorBody(output.body, context)];
1625
- case 1:
1626
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1627
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1628
- _b = errorCode;
1629
- switch (_b) {
1630
- case "InvalidParameterException": return [3, 2];
1631
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 2];
1632
- case "InvalidTagParameterException": return [3, 4];
1633
- case "com.amazonaws.ecrpublic#InvalidTagParameterException": return [3, 4];
1634
- case "RepositoryNotFoundException": return [3, 6];
1635
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 6];
1636
- case "ServerException": return [3, 8];
1637
- case "com.amazonaws.ecrpublic#ServerException": return [3, 8];
1638
- case "TooManyTagsException": return [3, 10];
1639
- case "com.amazonaws.ecrpublic#TooManyTagsException": return [3, 10];
1640
- }
1641
- return [3, 12];
1642
- case 2: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1643
- case 3: throw _d.sent();
1644
- case 4: return [4, deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context)];
1645
- case 5: throw _d.sent();
1646
- case 6: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1647
- case 7: throw _d.sent();
1648
- case 8: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1649
- case 9: throw _d.sent();
1650
- case 10: return [4, deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context)];
1651
- case 11: throw _d.sent();
1652
- case 12:
1653
- parsedBody = parsedOutput.body;
1654
- throwDefaultError({
1655
- output: output,
1656
- parsedBody: parsedBody,
1657
- exceptionCtor: __BaseException,
1658
- errorCode: errorCode,
1659
- });
1660
- _d.label = 13;
1661
- case 13: return [2];
1662
- }
1663
- });
1664
- }); };
1665
- export var deserializeAws_json1_1UploadLayerPartCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1666
- var data, contents, response;
1667
- return __generator(this, function (_a) {
1668
- switch (_a.label) {
1669
- case 0:
1670
- if (output.statusCode >= 300) {
1671
- return [2, deserializeAws_json1_1UploadLayerPartCommandError(output, context)];
1672
- }
1673
- return [4, parseBody(output.body, context)];
1674
- case 1:
1675
- data = _a.sent();
1676
- contents = {};
1677
- contents = deserializeAws_json1_1UploadLayerPartResponse(data, context);
1678
- response = __assign({ $metadata: deserializeMetadata(output) }, contents);
1679
- return [2, Promise.resolve(response)];
1680
- }
1681
- });
1682
- }); };
1683
- var deserializeAws_json1_1UploadLayerPartCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1684
- var parsedOutput, _a, errorCode, _b, parsedBody;
1685
- var _c;
1686
- return __generator(this, function (_d) {
1687
- switch (_d.label) {
1688
- case 0:
1689
- _a = [__assign({}, output)];
1690
- _c = {};
1691
- return [4, parseErrorBody(output.body, context)];
1692
- case 1:
1693
- parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1694
- errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1695
- _b = errorCode;
1696
- switch (_b) {
1697
- case "InvalidLayerPartException": return [3, 2];
1698
- case "com.amazonaws.ecrpublic#InvalidLayerPartException": return [3, 2];
1699
- case "InvalidParameterException": return [3, 4];
1700
- case "com.amazonaws.ecrpublic#InvalidParameterException": return [3, 4];
1701
- case "LimitExceededException": return [3, 6];
1702
- case "com.amazonaws.ecrpublic#LimitExceededException": return [3, 6];
1703
- case "RegistryNotFoundException": return [3, 8];
1704
- case "com.amazonaws.ecrpublic#RegistryNotFoundException": return [3, 8];
1705
- case "RepositoryNotFoundException": return [3, 10];
1706
- case "com.amazonaws.ecrpublic#RepositoryNotFoundException": return [3, 10];
1707
- case "ServerException": return [3, 12];
1708
- case "com.amazonaws.ecrpublic#ServerException": return [3, 12];
1709
- case "UnsupportedCommandException": return [3, 14];
1710
- case "com.amazonaws.ecrpublic#UnsupportedCommandException": return [3, 14];
1711
- case "UploadNotFoundException": return [3, 16];
1712
- case "com.amazonaws.ecrpublic#UploadNotFoundException": return [3, 16];
1713
- }
1714
- return [3, 18];
1715
- case 2: return [4, deserializeAws_json1_1InvalidLayerPartExceptionResponse(parsedOutput, context)];
1716
- case 3: throw _d.sent();
1717
- case 4: return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
1718
- case 5: throw _d.sent();
1719
- case 6: return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
1720
- case 7: throw _d.sent();
1721
- case 8: return [4, deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context)];
1722
- case 9: throw _d.sent();
1723
- case 10: return [4, deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context)];
1724
- case 11: throw _d.sent();
1725
- case 12: return [4, deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)];
1726
- case 13: throw _d.sent();
1727
- case 14: return [4, deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context)];
1728
- case 15: throw _d.sent();
1729
- case 16: return [4, deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context)];
1730
- case 17: throw _d.sent();
1731
- case 18:
1732
- parsedBody = parsedOutput.body;
1733
- throwDefaultError({
1734
- output: output,
1735
- parsedBody: parsedBody,
1736
- exceptionCtor: __BaseException,
1737
- errorCode: errorCode,
1738
- });
1739
- _d.label = 19;
1740
- case 19: return [2];
1741
- }
1742
- });
1743
- }); };
1744
- var deserializeAws_json1_1EmptyUploadExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1745
- var body, deserialized, exception;
1746
- return __generator(this, function (_a) {
1747
- body = parsedOutput.body;
1748
- deserialized = deserializeAws_json1_1EmptyUploadException(body, context);
1749
- exception = new EmptyUploadException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1750
- return [2, __decorateServiceException(exception, body)];
1751
- });
1752
- }); };
1753
- var deserializeAws_json1_1ImageAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1754
- var body, deserialized, exception;
1755
- return __generator(this, function (_a) {
1756
- body = parsedOutput.body;
1757
- deserialized = deserializeAws_json1_1ImageAlreadyExistsException(body, context);
1758
- exception = new ImageAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1759
- return [2, __decorateServiceException(exception, body)];
1760
- });
1761
- }); };
1762
- var deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1763
- var body, deserialized, exception;
1764
- return __generator(this, function (_a) {
1765
- body = parsedOutput.body;
1766
- deserialized = deserializeAws_json1_1ImageDigestDoesNotMatchException(body, context);
1767
- exception = new ImageDigestDoesNotMatchException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1768
- return [2, __decorateServiceException(exception, body)];
1769
- });
1770
- }); };
1771
- var deserializeAws_json1_1ImageNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1772
- var body, deserialized, exception;
1773
- return __generator(this, function (_a) {
1774
- body = parsedOutput.body;
1775
- deserialized = deserializeAws_json1_1ImageNotFoundException(body, context);
1776
- exception = new ImageNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1777
- return [2, __decorateServiceException(exception, body)];
1778
- });
1779
- }); };
1780
- var deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1781
- var body, deserialized, exception;
1782
- return __generator(this, function (_a) {
1783
- body = parsedOutput.body;
1784
- deserialized = deserializeAws_json1_1ImageTagAlreadyExistsException(body, context);
1785
- exception = new ImageTagAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1786
- return [2, __decorateServiceException(exception, body)];
1787
- });
1788
- }); };
1789
- var deserializeAws_json1_1InvalidLayerExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1790
- var body, deserialized, exception;
1791
- return __generator(this, function (_a) {
1792
- body = parsedOutput.body;
1793
- deserialized = deserializeAws_json1_1InvalidLayerException(body, context);
1794
- exception = new InvalidLayerException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1795
- return [2, __decorateServiceException(exception, body)];
1796
- });
1797
- }); };
1798
- var deserializeAws_json1_1InvalidLayerPartExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1799
- var body, deserialized, exception;
1800
- return __generator(this, function (_a) {
1801
- body = parsedOutput.body;
1802
- deserialized = deserializeAws_json1_1InvalidLayerPartException(body, context);
1803
- exception = new InvalidLayerPartException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1804
- return [2, __decorateServiceException(exception, body)];
1805
- });
1806
- }); };
1807
- var deserializeAws_json1_1InvalidParameterExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1808
- var body, deserialized, exception;
1809
- return __generator(this, function (_a) {
1810
- body = parsedOutput.body;
1811
- deserialized = deserializeAws_json1_1InvalidParameterException(body, context);
1812
- exception = new InvalidParameterException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1813
- return [2, __decorateServiceException(exception, body)];
1814
- });
1815
- }); };
1816
- var deserializeAws_json1_1InvalidTagParameterExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1817
- var body, deserialized, exception;
1818
- return __generator(this, function (_a) {
1819
- body = parsedOutput.body;
1820
- deserialized = deserializeAws_json1_1InvalidTagParameterException(body, context);
1821
- exception = new InvalidTagParameterException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1822
- return [2, __decorateServiceException(exception, body)];
1823
- });
1824
- }); };
1825
- var deserializeAws_json1_1LayerAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1826
- var body, deserialized, exception;
1827
- return __generator(this, function (_a) {
1828
- body = parsedOutput.body;
1829
- deserialized = deserializeAws_json1_1LayerAlreadyExistsException(body, context);
1830
- exception = new LayerAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1831
- return [2, __decorateServiceException(exception, body)];
1832
- });
1833
- }); };
1834
- var deserializeAws_json1_1LayerPartTooSmallExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1835
- var body, deserialized, exception;
1836
- return __generator(this, function (_a) {
1837
- body = parsedOutput.body;
1838
- deserialized = deserializeAws_json1_1LayerPartTooSmallException(body, context);
1839
- exception = new LayerPartTooSmallException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1840
- return [2, __decorateServiceException(exception, body)];
1841
- });
1842
- }); };
1843
- var deserializeAws_json1_1LayersNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1844
- var body, deserialized, exception;
1845
- return __generator(this, function (_a) {
1846
- body = parsedOutput.body;
1847
- deserialized = deserializeAws_json1_1LayersNotFoundException(body, context);
1848
- exception = new LayersNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1849
- return [2, __decorateServiceException(exception, body)];
1850
- });
1851
- }); };
1852
- var deserializeAws_json1_1LimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1853
- var body, deserialized, exception;
1854
- return __generator(this, function (_a) {
1855
- body = parsedOutput.body;
1856
- deserialized = deserializeAws_json1_1LimitExceededException(body, context);
1857
- exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1858
- return [2, __decorateServiceException(exception, body)];
1859
- });
1860
- }); };
1861
- var deserializeAws_json1_1ReferencedImagesNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1862
- var body, deserialized, exception;
1863
- return __generator(this, function (_a) {
1864
- body = parsedOutput.body;
1865
- deserialized = deserializeAws_json1_1ReferencedImagesNotFoundException(body, context);
1866
- exception = new ReferencedImagesNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1867
- return [2, __decorateServiceException(exception, body)];
1868
- });
1869
- }); };
1870
- var deserializeAws_json1_1RegistryNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1871
- var body, deserialized, exception;
1872
- return __generator(this, function (_a) {
1873
- body = parsedOutput.body;
1874
- deserialized = deserializeAws_json1_1RegistryNotFoundException(body, context);
1875
- exception = new RegistryNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1876
- return [2, __decorateServiceException(exception, body)];
1877
- });
1878
- }); };
1879
- var deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1880
- var body, deserialized, exception;
1881
- return __generator(this, function (_a) {
1882
- body = parsedOutput.body;
1883
- deserialized = deserializeAws_json1_1RepositoryAlreadyExistsException(body, context);
1884
- exception = new RepositoryAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1885
- return [2, __decorateServiceException(exception, body)];
1886
- });
1887
- }); };
1888
- var deserializeAws_json1_1RepositoryNotEmptyExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1889
- var body, deserialized, exception;
1890
- return __generator(this, function (_a) {
1891
- body = parsedOutput.body;
1892
- deserialized = deserializeAws_json1_1RepositoryNotEmptyException(body, context);
1893
- exception = new RepositoryNotEmptyException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1894
- return [2, __decorateServiceException(exception, body)];
1895
- });
1896
- }); };
1897
- var deserializeAws_json1_1RepositoryNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1898
- var body, deserialized, exception;
1899
- return __generator(this, function (_a) {
1900
- body = parsedOutput.body;
1901
- deserialized = deserializeAws_json1_1RepositoryNotFoundException(body, context);
1902
- exception = new RepositoryNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1903
- return [2, __decorateServiceException(exception, body)];
1904
- });
1905
- }); };
1906
- var deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1907
- var body, deserialized, exception;
1908
- return __generator(this, function (_a) {
1909
- body = parsedOutput.body;
1910
- deserialized = deserializeAws_json1_1RepositoryPolicyNotFoundException(body, context);
1911
- exception = new RepositoryPolicyNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1912
- return [2, __decorateServiceException(exception, body)];
1913
- });
1914
- }); };
1915
- var deserializeAws_json1_1ServerExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1916
- var body, deserialized, exception;
1917
- return __generator(this, function (_a) {
1918
- body = parsedOutput.body;
1919
- deserialized = deserializeAws_json1_1ServerException(body, context);
1920
- exception = new ServerException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1921
- return [2, __decorateServiceException(exception, body)];
1922
- });
1923
- }); };
1924
- var deserializeAws_json1_1TooManyTagsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1925
- var body, deserialized, exception;
1926
- return __generator(this, function (_a) {
1927
- body = parsedOutput.body;
1928
- deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
1929
- exception = new TooManyTagsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1930
- return [2, __decorateServiceException(exception, body)];
1931
- });
1932
- }); };
1933
- var deserializeAws_json1_1UnsupportedCommandExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1934
- var body, deserialized, exception;
1935
- return __generator(this, function (_a) {
1936
- body = parsedOutput.body;
1937
- deserialized = deserializeAws_json1_1UnsupportedCommandException(body, context);
1938
- exception = new UnsupportedCommandException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1939
- return [2, __decorateServiceException(exception, body)];
1940
- });
1941
- }); };
1942
- var deserializeAws_json1_1UploadNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
1943
- var body, deserialized, exception;
1944
- return __generator(this, function (_a) {
1945
- body = parsedOutput.body;
1946
- deserialized = deserializeAws_json1_1UploadNotFoundException(body, context);
1947
- exception = new UploadNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
1948
- return [2, __decorateServiceException(exception, body)];
1949
- });
1950
- }); };
1951
- var serializeAws_json1_1ArchitectureList = function (input, context) {
5
+ export const serializeAws_json1_1BatchCheckLayerAvailabilityCommand = async (input, context) => {
6
+ const headers = {
7
+ "content-type": "application/x-amz-json-1.1",
8
+ "x-amz-target": "SpencerFrontendService.BatchCheckLayerAvailability",
9
+ };
10
+ let body;
11
+ body = JSON.stringify(serializeAws_json1_1BatchCheckLayerAvailabilityRequest(input, context));
12
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
13
+ };
14
+ export const serializeAws_json1_1BatchDeleteImageCommand = async (input, context) => {
15
+ const headers = {
16
+ "content-type": "application/x-amz-json-1.1",
17
+ "x-amz-target": "SpencerFrontendService.BatchDeleteImage",
18
+ };
19
+ let body;
20
+ body = JSON.stringify(serializeAws_json1_1BatchDeleteImageRequest(input, context));
21
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
+ };
23
+ export const serializeAws_json1_1CompleteLayerUploadCommand = async (input, context) => {
24
+ const headers = {
25
+ "content-type": "application/x-amz-json-1.1",
26
+ "x-amz-target": "SpencerFrontendService.CompleteLayerUpload",
27
+ };
28
+ let body;
29
+ body = JSON.stringify(serializeAws_json1_1CompleteLayerUploadRequest(input, context));
30
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
31
+ };
32
+ export const serializeAws_json1_1CreateRepositoryCommand = async (input, context) => {
33
+ const headers = {
34
+ "content-type": "application/x-amz-json-1.1",
35
+ "x-amz-target": "SpencerFrontendService.CreateRepository",
36
+ };
37
+ let body;
38
+ body = JSON.stringify(serializeAws_json1_1CreateRepositoryRequest(input, context));
39
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
+ };
41
+ export const serializeAws_json1_1DeleteRepositoryCommand = async (input, context) => {
42
+ const headers = {
43
+ "content-type": "application/x-amz-json-1.1",
44
+ "x-amz-target": "SpencerFrontendService.DeleteRepository",
45
+ };
46
+ let body;
47
+ body = JSON.stringify(serializeAws_json1_1DeleteRepositoryRequest(input, context));
48
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
49
+ };
50
+ export const serializeAws_json1_1DeleteRepositoryPolicyCommand = async (input, context) => {
51
+ const headers = {
52
+ "content-type": "application/x-amz-json-1.1",
53
+ "x-amz-target": "SpencerFrontendService.DeleteRepositoryPolicy",
54
+ };
55
+ let body;
56
+ body = JSON.stringify(serializeAws_json1_1DeleteRepositoryPolicyRequest(input, context));
57
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
58
+ };
59
+ export const serializeAws_json1_1DescribeImagesCommand = async (input, context) => {
60
+ const headers = {
61
+ "content-type": "application/x-amz-json-1.1",
62
+ "x-amz-target": "SpencerFrontendService.DescribeImages",
63
+ };
64
+ let body;
65
+ body = JSON.stringify(serializeAws_json1_1DescribeImagesRequest(input, context));
66
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
67
+ };
68
+ export const serializeAws_json1_1DescribeImageTagsCommand = async (input, context) => {
69
+ const headers = {
70
+ "content-type": "application/x-amz-json-1.1",
71
+ "x-amz-target": "SpencerFrontendService.DescribeImageTags",
72
+ };
73
+ let body;
74
+ body = JSON.stringify(serializeAws_json1_1DescribeImageTagsRequest(input, context));
75
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
76
+ };
77
+ export const serializeAws_json1_1DescribeRegistriesCommand = async (input, context) => {
78
+ const headers = {
79
+ "content-type": "application/x-amz-json-1.1",
80
+ "x-amz-target": "SpencerFrontendService.DescribeRegistries",
81
+ };
82
+ let body;
83
+ body = JSON.stringify(serializeAws_json1_1DescribeRegistriesRequest(input, context));
84
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
85
+ };
86
+ export const serializeAws_json1_1DescribeRepositoriesCommand = async (input, context) => {
87
+ const headers = {
88
+ "content-type": "application/x-amz-json-1.1",
89
+ "x-amz-target": "SpencerFrontendService.DescribeRepositories",
90
+ };
91
+ let body;
92
+ body = JSON.stringify(serializeAws_json1_1DescribeRepositoriesRequest(input, context));
93
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
94
+ };
95
+ export const serializeAws_json1_1GetAuthorizationTokenCommand = async (input, context) => {
96
+ const headers = {
97
+ "content-type": "application/x-amz-json-1.1",
98
+ "x-amz-target": "SpencerFrontendService.GetAuthorizationToken",
99
+ };
100
+ let body;
101
+ body = JSON.stringify(serializeAws_json1_1GetAuthorizationTokenRequest(input, context));
102
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
103
+ };
104
+ export const serializeAws_json1_1GetRegistryCatalogDataCommand = async (input, context) => {
105
+ const headers = {
106
+ "content-type": "application/x-amz-json-1.1",
107
+ "x-amz-target": "SpencerFrontendService.GetRegistryCatalogData",
108
+ };
109
+ let body;
110
+ body = JSON.stringify(serializeAws_json1_1GetRegistryCatalogDataRequest(input, context));
111
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
112
+ };
113
+ export const serializeAws_json1_1GetRepositoryCatalogDataCommand = async (input, context) => {
114
+ const headers = {
115
+ "content-type": "application/x-amz-json-1.1",
116
+ "x-amz-target": "SpencerFrontendService.GetRepositoryCatalogData",
117
+ };
118
+ let body;
119
+ body = JSON.stringify(serializeAws_json1_1GetRepositoryCatalogDataRequest(input, context));
120
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
121
+ };
122
+ export const serializeAws_json1_1GetRepositoryPolicyCommand = async (input, context) => {
123
+ const headers = {
124
+ "content-type": "application/x-amz-json-1.1",
125
+ "x-amz-target": "SpencerFrontendService.GetRepositoryPolicy",
126
+ };
127
+ let body;
128
+ body = JSON.stringify(serializeAws_json1_1GetRepositoryPolicyRequest(input, context));
129
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
+ };
131
+ export const serializeAws_json1_1InitiateLayerUploadCommand = async (input, context) => {
132
+ const headers = {
133
+ "content-type": "application/x-amz-json-1.1",
134
+ "x-amz-target": "SpencerFrontendService.InitiateLayerUpload",
135
+ };
136
+ let body;
137
+ body = JSON.stringify(serializeAws_json1_1InitiateLayerUploadRequest(input, context));
138
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
139
+ };
140
+ export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
141
+ const headers = {
142
+ "content-type": "application/x-amz-json-1.1",
143
+ "x-amz-target": "SpencerFrontendService.ListTagsForResource",
144
+ };
145
+ let body;
146
+ body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
147
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
148
+ };
149
+ export const serializeAws_json1_1PutImageCommand = async (input, context) => {
150
+ const headers = {
151
+ "content-type": "application/x-amz-json-1.1",
152
+ "x-amz-target": "SpencerFrontendService.PutImage",
153
+ };
154
+ let body;
155
+ body = JSON.stringify(serializeAws_json1_1PutImageRequest(input, context));
156
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
157
+ };
158
+ export const serializeAws_json1_1PutRegistryCatalogDataCommand = async (input, context) => {
159
+ const headers = {
160
+ "content-type": "application/x-amz-json-1.1",
161
+ "x-amz-target": "SpencerFrontendService.PutRegistryCatalogData",
162
+ };
163
+ let body;
164
+ body = JSON.stringify(serializeAws_json1_1PutRegistryCatalogDataRequest(input, context));
165
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
166
+ };
167
+ export const serializeAws_json1_1PutRepositoryCatalogDataCommand = async (input, context) => {
168
+ const headers = {
169
+ "content-type": "application/x-amz-json-1.1",
170
+ "x-amz-target": "SpencerFrontendService.PutRepositoryCatalogData",
171
+ };
172
+ let body;
173
+ body = JSON.stringify(serializeAws_json1_1PutRepositoryCatalogDataRequest(input, context));
174
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
175
+ };
176
+ export const serializeAws_json1_1SetRepositoryPolicyCommand = async (input, context) => {
177
+ const headers = {
178
+ "content-type": "application/x-amz-json-1.1",
179
+ "x-amz-target": "SpencerFrontendService.SetRepositoryPolicy",
180
+ };
181
+ let body;
182
+ body = JSON.stringify(serializeAws_json1_1SetRepositoryPolicyRequest(input, context));
183
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
184
+ };
185
+ export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
186
+ const headers = {
187
+ "content-type": "application/x-amz-json-1.1",
188
+ "x-amz-target": "SpencerFrontendService.TagResource",
189
+ };
190
+ let body;
191
+ body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
192
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
193
+ };
194
+ export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
195
+ const headers = {
196
+ "content-type": "application/x-amz-json-1.1",
197
+ "x-amz-target": "SpencerFrontendService.UntagResource",
198
+ };
199
+ let body;
200
+ body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
201
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
202
+ };
203
+ export const serializeAws_json1_1UploadLayerPartCommand = async (input, context) => {
204
+ const headers = {
205
+ "content-type": "application/x-amz-json-1.1",
206
+ "x-amz-target": "SpencerFrontendService.UploadLayerPart",
207
+ };
208
+ let body;
209
+ body = JSON.stringify(serializeAws_json1_1UploadLayerPartRequest(input, context));
210
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
211
+ };
212
+ export const deserializeAws_json1_1BatchCheckLayerAvailabilityCommand = async (output, context) => {
213
+ if (output.statusCode >= 300) {
214
+ return deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError(output, context);
215
+ }
216
+ const data = await parseBody(output.body, context);
217
+ let contents = {};
218
+ contents = deserializeAws_json1_1BatchCheckLayerAvailabilityResponse(data, context);
219
+ const response = {
220
+ $metadata: deserializeMetadata(output),
221
+ ...contents,
222
+ };
223
+ return Promise.resolve(response);
224
+ };
225
+ const deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError = async (output, context) => {
226
+ const parsedOutput = {
227
+ ...output,
228
+ body: await parseErrorBody(output.body, context),
229
+ };
230
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
231
+ switch (errorCode) {
232
+ case "InvalidParameterException":
233
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
234
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
235
+ case "RegistryNotFoundException":
236
+ case "com.amazonaws.ecrpublic#RegistryNotFoundException":
237
+ throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
238
+ case "RepositoryNotFoundException":
239
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
240
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
241
+ case "ServerException":
242
+ case "com.amazonaws.ecrpublic#ServerException":
243
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
244
+ default:
245
+ const parsedBody = parsedOutput.body;
246
+ throwDefaultError({
247
+ output,
248
+ parsedBody,
249
+ exceptionCtor: __BaseException,
250
+ errorCode,
251
+ });
252
+ }
253
+ };
254
+ export const deserializeAws_json1_1BatchDeleteImageCommand = async (output, context) => {
255
+ if (output.statusCode >= 300) {
256
+ return deserializeAws_json1_1BatchDeleteImageCommandError(output, context);
257
+ }
258
+ const data = await parseBody(output.body, context);
259
+ let contents = {};
260
+ contents = deserializeAws_json1_1BatchDeleteImageResponse(data, context);
261
+ const response = {
262
+ $metadata: deserializeMetadata(output),
263
+ ...contents,
264
+ };
265
+ return Promise.resolve(response);
266
+ };
267
+ const deserializeAws_json1_1BatchDeleteImageCommandError = async (output, context) => {
268
+ const parsedOutput = {
269
+ ...output,
270
+ body: await parseErrorBody(output.body, context),
271
+ };
272
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
273
+ switch (errorCode) {
274
+ case "InvalidParameterException":
275
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
276
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
277
+ case "RepositoryNotFoundException":
278
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
279
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
280
+ case "ServerException":
281
+ case "com.amazonaws.ecrpublic#ServerException":
282
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
283
+ default:
284
+ const parsedBody = parsedOutput.body;
285
+ throwDefaultError({
286
+ output,
287
+ parsedBody,
288
+ exceptionCtor: __BaseException,
289
+ errorCode,
290
+ });
291
+ }
292
+ };
293
+ export const deserializeAws_json1_1CompleteLayerUploadCommand = async (output, context) => {
294
+ if (output.statusCode >= 300) {
295
+ return deserializeAws_json1_1CompleteLayerUploadCommandError(output, context);
296
+ }
297
+ const data = await parseBody(output.body, context);
298
+ let contents = {};
299
+ contents = deserializeAws_json1_1CompleteLayerUploadResponse(data, context);
300
+ const response = {
301
+ $metadata: deserializeMetadata(output),
302
+ ...contents,
303
+ };
304
+ return Promise.resolve(response);
305
+ };
306
+ const deserializeAws_json1_1CompleteLayerUploadCommandError = async (output, context) => {
307
+ const parsedOutput = {
308
+ ...output,
309
+ body: await parseErrorBody(output.body, context),
310
+ };
311
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
312
+ switch (errorCode) {
313
+ case "EmptyUploadException":
314
+ case "com.amazonaws.ecrpublic#EmptyUploadException":
315
+ throw await deserializeAws_json1_1EmptyUploadExceptionResponse(parsedOutput, context);
316
+ case "InvalidLayerException":
317
+ case "com.amazonaws.ecrpublic#InvalidLayerException":
318
+ throw await deserializeAws_json1_1InvalidLayerExceptionResponse(parsedOutput, context);
319
+ case "InvalidParameterException":
320
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
321
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
322
+ case "LayerAlreadyExistsException":
323
+ case "com.amazonaws.ecrpublic#LayerAlreadyExistsException":
324
+ throw await deserializeAws_json1_1LayerAlreadyExistsExceptionResponse(parsedOutput, context);
325
+ case "LayerPartTooSmallException":
326
+ case "com.amazonaws.ecrpublic#LayerPartTooSmallException":
327
+ throw await deserializeAws_json1_1LayerPartTooSmallExceptionResponse(parsedOutput, context);
328
+ case "RegistryNotFoundException":
329
+ case "com.amazonaws.ecrpublic#RegistryNotFoundException":
330
+ throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
331
+ case "RepositoryNotFoundException":
332
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
333
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
334
+ case "ServerException":
335
+ case "com.amazonaws.ecrpublic#ServerException":
336
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
337
+ case "UnsupportedCommandException":
338
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
339
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
340
+ case "UploadNotFoundException":
341
+ case "com.amazonaws.ecrpublic#UploadNotFoundException":
342
+ throw await deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context);
343
+ default:
344
+ const parsedBody = parsedOutput.body;
345
+ throwDefaultError({
346
+ output,
347
+ parsedBody,
348
+ exceptionCtor: __BaseException,
349
+ errorCode,
350
+ });
351
+ }
352
+ };
353
+ export const deserializeAws_json1_1CreateRepositoryCommand = async (output, context) => {
354
+ if (output.statusCode >= 300) {
355
+ return deserializeAws_json1_1CreateRepositoryCommandError(output, context);
356
+ }
357
+ const data = await parseBody(output.body, context);
358
+ let contents = {};
359
+ contents = deserializeAws_json1_1CreateRepositoryResponse(data, context);
360
+ const response = {
361
+ $metadata: deserializeMetadata(output),
362
+ ...contents,
363
+ };
364
+ return Promise.resolve(response);
365
+ };
366
+ const deserializeAws_json1_1CreateRepositoryCommandError = async (output, context) => {
367
+ const parsedOutput = {
368
+ ...output,
369
+ body: await parseErrorBody(output.body, context),
370
+ };
371
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
372
+ switch (errorCode) {
373
+ case "InvalidParameterException":
374
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
375
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
376
+ case "InvalidTagParameterException":
377
+ case "com.amazonaws.ecrpublic#InvalidTagParameterException":
378
+ throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
379
+ case "LimitExceededException":
380
+ case "com.amazonaws.ecrpublic#LimitExceededException":
381
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
382
+ case "RepositoryAlreadyExistsException":
383
+ case "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException":
384
+ throw await deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse(parsedOutput, context);
385
+ case "ServerException":
386
+ case "com.amazonaws.ecrpublic#ServerException":
387
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
388
+ case "TooManyTagsException":
389
+ case "com.amazonaws.ecrpublic#TooManyTagsException":
390
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
391
+ default:
392
+ const parsedBody = parsedOutput.body;
393
+ throwDefaultError({
394
+ output,
395
+ parsedBody,
396
+ exceptionCtor: __BaseException,
397
+ errorCode,
398
+ });
399
+ }
400
+ };
401
+ export const deserializeAws_json1_1DeleteRepositoryCommand = async (output, context) => {
402
+ if (output.statusCode >= 300) {
403
+ return deserializeAws_json1_1DeleteRepositoryCommandError(output, context);
404
+ }
405
+ const data = await parseBody(output.body, context);
406
+ let contents = {};
407
+ contents = deserializeAws_json1_1DeleteRepositoryResponse(data, context);
408
+ const response = {
409
+ $metadata: deserializeMetadata(output),
410
+ ...contents,
411
+ };
412
+ return Promise.resolve(response);
413
+ };
414
+ const deserializeAws_json1_1DeleteRepositoryCommandError = async (output, context) => {
415
+ const parsedOutput = {
416
+ ...output,
417
+ body: await parseErrorBody(output.body, context),
418
+ };
419
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
420
+ switch (errorCode) {
421
+ case "InvalidParameterException":
422
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
423
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
424
+ case "RepositoryNotEmptyException":
425
+ case "com.amazonaws.ecrpublic#RepositoryNotEmptyException":
426
+ throw await deserializeAws_json1_1RepositoryNotEmptyExceptionResponse(parsedOutput, context);
427
+ case "RepositoryNotFoundException":
428
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
429
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
430
+ case "ServerException":
431
+ case "com.amazonaws.ecrpublic#ServerException":
432
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
433
+ default:
434
+ const parsedBody = parsedOutput.body;
435
+ throwDefaultError({
436
+ output,
437
+ parsedBody,
438
+ exceptionCtor: __BaseException,
439
+ errorCode,
440
+ });
441
+ }
442
+ };
443
+ export const deserializeAws_json1_1DeleteRepositoryPolicyCommand = async (output, context) => {
444
+ if (output.statusCode >= 300) {
445
+ return deserializeAws_json1_1DeleteRepositoryPolicyCommandError(output, context);
446
+ }
447
+ const data = await parseBody(output.body, context);
448
+ let contents = {};
449
+ contents = deserializeAws_json1_1DeleteRepositoryPolicyResponse(data, context);
450
+ const response = {
451
+ $metadata: deserializeMetadata(output),
452
+ ...contents,
453
+ };
454
+ return Promise.resolve(response);
455
+ };
456
+ const deserializeAws_json1_1DeleteRepositoryPolicyCommandError = async (output, context) => {
457
+ const parsedOutput = {
458
+ ...output,
459
+ body: await parseErrorBody(output.body, context),
460
+ };
461
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
462
+ switch (errorCode) {
463
+ case "InvalidParameterException":
464
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
465
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
466
+ case "RepositoryNotFoundException":
467
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
468
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
469
+ case "RepositoryPolicyNotFoundException":
470
+ case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
471
+ throw await deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context);
472
+ case "ServerException":
473
+ case "com.amazonaws.ecrpublic#ServerException":
474
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
475
+ default:
476
+ const parsedBody = parsedOutput.body;
477
+ throwDefaultError({
478
+ output,
479
+ parsedBody,
480
+ exceptionCtor: __BaseException,
481
+ errorCode,
482
+ });
483
+ }
484
+ };
485
+ export const deserializeAws_json1_1DescribeImagesCommand = async (output, context) => {
486
+ if (output.statusCode >= 300) {
487
+ return deserializeAws_json1_1DescribeImagesCommandError(output, context);
488
+ }
489
+ const data = await parseBody(output.body, context);
490
+ let contents = {};
491
+ contents = deserializeAws_json1_1DescribeImagesResponse(data, context);
492
+ const response = {
493
+ $metadata: deserializeMetadata(output),
494
+ ...contents,
495
+ };
496
+ return Promise.resolve(response);
497
+ };
498
+ const deserializeAws_json1_1DescribeImagesCommandError = async (output, context) => {
499
+ const parsedOutput = {
500
+ ...output,
501
+ body: await parseErrorBody(output.body, context),
502
+ };
503
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
504
+ switch (errorCode) {
505
+ case "ImageNotFoundException":
506
+ case "com.amazonaws.ecrpublic#ImageNotFoundException":
507
+ throw await deserializeAws_json1_1ImageNotFoundExceptionResponse(parsedOutput, context);
508
+ case "InvalidParameterException":
509
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
510
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
511
+ case "RepositoryNotFoundException":
512
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
513
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
514
+ case "ServerException":
515
+ case "com.amazonaws.ecrpublic#ServerException":
516
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
517
+ default:
518
+ const parsedBody = parsedOutput.body;
519
+ throwDefaultError({
520
+ output,
521
+ parsedBody,
522
+ exceptionCtor: __BaseException,
523
+ errorCode,
524
+ });
525
+ }
526
+ };
527
+ export const deserializeAws_json1_1DescribeImageTagsCommand = async (output, context) => {
528
+ if (output.statusCode >= 300) {
529
+ return deserializeAws_json1_1DescribeImageTagsCommandError(output, context);
530
+ }
531
+ const data = await parseBody(output.body, context);
532
+ let contents = {};
533
+ contents = deserializeAws_json1_1DescribeImageTagsResponse(data, context);
534
+ const response = {
535
+ $metadata: deserializeMetadata(output),
536
+ ...contents,
537
+ };
538
+ return Promise.resolve(response);
539
+ };
540
+ const deserializeAws_json1_1DescribeImageTagsCommandError = async (output, context) => {
541
+ const parsedOutput = {
542
+ ...output,
543
+ body: await parseErrorBody(output.body, context),
544
+ };
545
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
546
+ switch (errorCode) {
547
+ case "InvalidParameterException":
548
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
549
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
550
+ case "RepositoryNotFoundException":
551
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
552
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
553
+ case "ServerException":
554
+ case "com.amazonaws.ecrpublic#ServerException":
555
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
556
+ default:
557
+ const parsedBody = parsedOutput.body;
558
+ throwDefaultError({
559
+ output,
560
+ parsedBody,
561
+ exceptionCtor: __BaseException,
562
+ errorCode,
563
+ });
564
+ }
565
+ };
566
+ export const deserializeAws_json1_1DescribeRegistriesCommand = async (output, context) => {
567
+ if (output.statusCode >= 300) {
568
+ return deserializeAws_json1_1DescribeRegistriesCommandError(output, context);
569
+ }
570
+ const data = await parseBody(output.body, context);
571
+ let contents = {};
572
+ contents = deserializeAws_json1_1DescribeRegistriesResponse(data, context);
573
+ const response = {
574
+ $metadata: deserializeMetadata(output),
575
+ ...contents,
576
+ };
577
+ return Promise.resolve(response);
578
+ };
579
+ const deserializeAws_json1_1DescribeRegistriesCommandError = async (output, context) => {
580
+ const parsedOutput = {
581
+ ...output,
582
+ body: await parseErrorBody(output.body, context),
583
+ };
584
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
585
+ switch (errorCode) {
586
+ case "InvalidParameterException":
587
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
588
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
589
+ case "ServerException":
590
+ case "com.amazonaws.ecrpublic#ServerException":
591
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
592
+ case "UnsupportedCommandException":
593
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
594
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
595
+ default:
596
+ const parsedBody = parsedOutput.body;
597
+ throwDefaultError({
598
+ output,
599
+ parsedBody,
600
+ exceptionCtor: __BaseException,
601
+ errorCode,
602
+ });
603
+ }
604
+ };
605
+ export const deserializeAws_json1_1DescribeRepositoriesCommand = async (output, context) => {
606
+ if (output.statusCode >= 300) {
607
+ return deserializeAws_json1_1DescribeRepositoriesCommandError(output, context);
608
+ }
609
+ const data = await parseBody(output.body, context);
610
+ let contents = {};
611
+ contents = deserializeAws_json1_1DescribeRepositoriesResponse(data, context);
612
+ const response = {
613
+ $metadata: deserializeMetadata(output),
614
+ ...contents,
615
+ };
616
+ return Promise.resolve(response);
617
+ };
618
+ const deserializeAws_json1_1DescribeRepositoriesCommandError = async (output, context) => {
619
+ const parsedOutput = {
620
+ ...output,
621
+ body: await parseErrorBody(output.body, context),
622
+ };
623
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
624
+ switch (errorCode) {
625
+ case "InvalidParameterException":
626
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
627
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
628
+ case "RepositoryNotFoundException":
629
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
630
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
631
+ case "ServerException":
632
+ case "com.amazonaws.ecrpublic#ServerException":
633
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
634
+ default:
635
+ const parsedBody = parsedOutput.body;
636
+ throwDefaultError({
637
+ output,
638
+ parsedBody,
639
+ exceptionCtor: __BaseException,
640
+ errorCode,
641
+ });
642
+ }
643
+ };
644
+ export const deserializeAws_json1_1GetAuthorizationTokenCommand = async (output, context) => {
645
+ if (output.statusCode >= 300) {
646
+ return deserializeAws_json1_1GetAuthorizationTokenCommandError(output, context);
647
+ }
648
+ const data = await parseBody(output.body, context);
649
+ let contents = {};
650
+ contents = deserializeAws_json1_1GetAuthorizationTokenResponse(data, context);
651
+ const response = {
652
+ $metadata: deserializeMetadata(output),
653
+ ...contents,
654
+ };
655
+ return Promise.resolve(response);
656
+ };
657
+ const deserializeAws_json1_1GetAuthorizationTokenCommandError = async (output, context) => {
658
+ const parsedOutput = {
659
+ ...output,
660
+ body: await parseErrorBody(output.body, context),
661
+ };
662
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
663
+ switch (errorCode) {
664
+ case "InvalidParameterException":
665
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
666
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
667
+ case "ServerException":
668
+ case "com.amazonaws.ecrpublic#ServerException":
669
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
670
+ default:
671
+ const parsedBody = parsedOutput.body;
672
+ throwDefaultError({
673
+ output,
674
+ parsedBody,
675
+ exceptionCtor: __BaseException,
676
+ errorCode,
677
+ });
678
+ }
679
+ };
680
+ export const deserializeAws_json1_1GetRegistryCatalogDataCommand = async (output, context) => {
681
+ if (output.statusCode >= 300) {
682
+ return deserializeAws_json1_1GetRegistryCatalogDataCommandError(output, context);
683
+ }
684
+ const data = await parseBody(output.body, context);
685
+ let contents = {};
686
+ contents = deserializeAws_json1_1GetRegistryCatalogDataResponse(data, context);
687
+ const response = {
688
+ $metadata: deserializeMetadata(output),
689
+ ...contents,
690
+ };
691
+ return Promise.resolve(response);
692
+ };
693
+ const deserializeAws_json1_1GetRegistryCatalogDataCommandError = async (output, context) => {
694
+ const parsedOutput = {
695
+ ...output,
696
+ body: await parseErrorBody(output.body, context),
697
+ };
698
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
699
+ switch (errorCode) {
700
+ case "ServerException":
701
+ case "com.amazonaws.ecrpublic#ServerException":
702
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
703
+ case "UnsupportedCommandException":
704
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
705
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
706
+ default:
707
+ const parsedBody = parsedOutput.body;
708
+ throwDefaultError({
709
+ output,
710
+ parsedBody,
711
+ exceptionCtor: __BaseException,
712
+ errorCode,
713
+ });
714
+ }
715
+ };
716
+ export const deserializeAws_json1_1GetRepositoryCatalogDataCommand = async (output, context) => {
717
+ if (output.statusCode >= 300) {
718
+ return deserializeAws_json1_1GetRepositoryCatalogDataCommandError(output, context);
719
+ }
720
+ const data = await parseBody(output.body, context);
721
+ let contents = {};
722
+ contents = deserializeAws_json1_1GetRepositoryCatalogDataResponse(data, context);
723
+ const response = {
724
+ $metadata: deserializeMetadata(output),
725
+ ...contents,
726
+ };
727
+ return Promise.resolve(response);
728
+ };
729
+ const deserializeAws_json1_1GetRepositoryCatalogDataCommandError = async (output, context) => {
730
+ const parsedOutput = {
731
+ ...output,
732
+ body: await parseErrorBody(output.body, context),
733
+ };
734
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
735
+ switch (errorCode) {
736
+ case "InvalidParameterException":
737
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
738
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
739
+ case "RepositoryNotFoundException":
740
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
741
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
742
+ case "ServerException":
743
+ case "com.amazonaws.ecrpublic#ServerException":
744
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
745
+ default:
746
+ const parsedBody = parsedOutput.body;
747
+ throwDefaultError({
748
+ output,
749
+ parsedBody,
750
+ exceptionCtor: __BaseException,
751
+ errorCode,
752
+ });
753
+ }
754
+ };
755
+ export const deserializeAws_json1_1GetRepositoryPolicyCommand = async (output, context) => {
756
+ if (output.statusCode >= 300) {
757
+ return deserializeAws_json1_1GetRepositoryPolicyCommandError(output, context);
758
+ }
759
+ const data = await parseBody(output.body, context);
760
+ let contents = {};
761
+ contents = deserializeAws_json1_1GetRepositoryPolicyResponse(data, context);
762
+ const response = {
763
+ $metadata: deserializeMetadata(output),
764
+ ...contents,
765
+ };
766
+ return Promise.resolve(response);
767
+ };
768
+ const deserializeAws_json1_1GetRepositoryPolicyCommandError = async (output, context) => {
769
+ const parsedOutput = {
770
+ ...output,
771
+ body: await parseErrorBody(output.body, context),
772
+ };
773
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
774
+ switch (errorCode) {
775
+ case "InvalidParameterException":
776
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
777
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
778
+ case "RepositoryNotFoundException":
779
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
780
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
781
+ case "RepositoryPolicyNotFoundException":
782
+ case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
783
+ throw await deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context);
784
+ case "ServerException":
785
+ case "com.amazonaws.ecrpublic#ServerException":
786
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
787
+ default:
788
+ const parsedBody = parsedOutput.body;
789
+ throwDefaultError({
790
+ output,
791
+ parsedBody,
792
+ exceptionCtor: __BaseException,
793
+ errorCode,
794
+ });
795
+ }
796
+ };
797
+ export const deserializeAws_json1_1InitiateLayerUploadCommand = async (output, context) => {
798
+ if (output.statusCode >= 300) {
799
+ return deserializeAws_json1_1InitiateLayerUploadCommandError(output, context);
800
+ }
801
+ const data = await parseBody(output.body, context);
802
+ let contents = {};
803
+ contents = deserializeAws_json1_1InitiateLayerUploadResponse(data, context);
804
+ const response = {
805
+ $metadata: deserializeMetadata(output),
806
+ ...contents,
807
+ };
808
+ return Promise.resolve(response);
809
+ };
810
+ const deserializeAws_json1_1InitiateLayerUploadCommandError = async (output, context) => {
811
+ const parsedOutput = {
812
+ ...output,
813
+ body: await parseErrorBody(output.body, context),
814
+ };
815
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
816
+ switch (errorCode) {
817
+ case "InvalidParameterException":
818
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
819
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
820
+ case "RegistryNotFoundException":
821
+ case "com.amazonaws.ecrpublic#RegistryNotFoundException":
822
+ throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
823
+ case "RepositoryNotFoundException":
824
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
825
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
826
+ case "ServerException":
827
+ case "com.amazonaws.ecrpublic#ServerException":
828
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
829
+ case "UnsupportedCommandException":
830
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
831
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
832
+ default:
833
+ const parsedBody = parsedOutput.body;
834
+ throwDefaultError({
835
+ output,
836
+ parsedBody,
837
+ exceptionCtor: __BaseException,
838
+ errorCode,
839
+ });
840
+ }
841
+ };
842
+ export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
843
+ if (output.statusCode >= 300) {
844
+ return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
845
+ }
846
+ const data = await parseBody(output.body, context);
847
+ let contents = {};
848
+ contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
849
+ const response = {
850
+ $metadata: deserializeMetadata(output),
851
+ ...contents,
852
+ };
853
+ return Promise.resolve(response);
854
+ };
855
+ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
856
+ const parsedOutput = {
857
+ ...output,
858
+ body: await parseErrorBody(output.body, context),
859
+ };
860
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
861
+ switch (errorCode) {
862
+ case "InvalidParameterException":
863
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
864
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
865
+ case "RepositoryNotFoundException":
866
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
867
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
868
+ case "ServerException":
869
+ case "com.amazonaws.ecrpublic#ServerException":
870
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
871
+ default:
872
+ const parsedBody = parsedOutput.body;
873
+ throwDefaultError({
874
+ output,
875
+ parsedBody,
876
+ exceptionCtor: __BaseException,
877
+ errorCode,
878
+ });
879
+ }
880
+ };
881
+ export const deserializeAws_json1_1PutImageCommand = async (output, context) => {
882
+ if (output.statusCode >= 300) {
883
+ return deserializeAws_json1_1PutImageCommandError(output, context);
884
+ }
885
+ const data = await parseBody(output.body, context);
886
+ let contents = {};
887
+ contents = deserializeAws_json1_1PutImageResponse(data, context);
888
+ const response = {
889
+ $metadata: deserializeMetadata(output),
890
+ ...contents,
891
+ };
892
+ return Promise.resolve(response);
893
+ };
894
+ const deserializeAws_json1_1PutImageCommandError = async (output, context) => {
895
+ const parsedOutput = {
896
+ ...output,
897
+ body: await parseErrorBody(output.body, context),
898
+ };
899
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
900
+ switch (errorCode) {
901
+ case "ImageAlreadyExistsException":
902
+ case "com.amazonaws.ecrpublic#ImageAlreadyExistsException":
903
+ throw await deserializeAws_json1_1ImageAlreadyExistsExceptionResponse(parsedOutput, context);
904
+ case "ImageDigestDoesNotMatchException":
905
+ case "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException":
906
+ throw await deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse(parsedOutput, context);
907
+ case "ImageTagAlreadyExistsException":
908
+ case "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException":
909
+ throw await deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse(parsedOutput, context);
910
+ case "InvalidParameterException":
911
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
912
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
913
+ case "LayersNotFoundException":
914
+ case "com.amazonaws.ecrpublic#LayersNotFoundException":
915
+ throw await deserializeAws_json1_1LayersNotFoundExceptionResponse(parsedOutput, context);
916
+ case "LimitExceededException":
917
+ case "com.amazonaws.ecrpublic#LimitExceededException":
918
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
919
+ case "ReferencedImagesNotFoundException":
920
+ case "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException":
921
+ throw await deserializeAws_json1_1ReferencedImagesNotFoundExceptionResponse(parsedOutput, context);
922
+ case "RegistryNotFoundException":
923
+ case "com.amazonaws.ecrpublic#RegistryNotFoundException":
924
+ throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
925
+ case "RepositoryNotFoundException":
926
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
927
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
928
+ case "ServerException":
929
+ case "com.amazonaws.ecrpublic#ServerException":
930
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
931
+ case "UnsupportedCommandException":
932
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
933
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
934
+ default:
935
+ const parsedBody = parsedOutput.body;
936
+ throwDefaultError({
937
+ output,
938
+ parsedBody,
939
+ exceptionCtor: __BaseException,
940
+ errorCode,
941
+ });
942
+ }
943
+ };
944
+ export const deserializeAws_json1_1PutRegistryCatalogDataCommand = async (output, context) => {
945
+ if (output.statusCode >= 300) {
946
+ return deserializeAws_json1_1PutRegistryCatalogDataCommandError(output, context);
947
+ }
948
+ const data = await parseBody(output.body, context);
949
+ let contents = {};
950
+ contents = deserializeAws_json1_1PutRegistryCatalogDataResponse(data, context);
951
+ const response = {
952
+ $metadata: deserializeMetadata(output),
953
+ ...contents,
954
+ };
955
+ return Promise.resolve(response);
956
+ };
957
+ const deserializeAws_json1_1PutRegistryCatalogDataCommandError = async (output, context) => {
958
+ const parsedOutput = {
959
+ ...output,
960
+ body: await parseErrorBody(output.body, context),
961
+ };
962
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
963
+ switch (errorCode) {
964
+ case "InvalidParameterException":
965
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
966
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
967
+ case "ServerException":
968
+ case "com.amazonaws.ecrpublic#ServerException":
969
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
970
+ case "UnsupportedCommandException":
971
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
972
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
973
+ default:
974
+ const parsedBody = parsedOutput.body;
975
+ throwDefaultError({
976
+ output,
977
+ parsedBody,
978
+ exceptionCtor: __BaseException,
979
+ errorCode,
980
+ });
981
+ }
982
+ };
983
+ export const deserializeAws_json1_1PutRepositoryCatalogDataCommand = async (output, context) => {
984
+ if (output.statusCode >= 300) {
985
+ return deserializeAws_json1_1PutRepositoryCatalogDataCommandError(output, context);
986
+ }
987
+ const data = await parseBody(output.body, context);
988
+ let contents = {};
989
+ contents = deserializeAws_json1_1PutRepositoryCatalogDataResponse(data, context);
990
+ const response = {
991
+ $metadata: deserializeMetadata(output),
992
+ ...contents,
993
+ };
994
+ return Promise.resolve(response);
995
+ };
996
+ const deserializeAws_json1_1PutRepositoryCatalogDataCommandError = async (output, context) => {
997
+ const parsedOutput = {
998
+ ...output,
999
+ body: await parseErrorBody(output.body, context),
1000
+ };
1001
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1002
+ switch (errorCode) {
1003
+ case "InvalidParameterException":
1004
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
1005
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1006
+ case "RepositoryNotFoundException":
1007
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
1008
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
1009
+ case "ServerException":
1010
+ case "com.amazonaws.ecrpublic#ServerException":
1011
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1012
+ default:
1013
+ const parsedBody = parsedOutput.body;
1014
+ throwDefaultError({
1015
+ output,
1016
+ parsedBody,
1017
+ exceptionCtor: __BaseException,
1018
+ errorCode,
1019
+ });
1020
+ }
1021
+ };
1022
+ export const deserializeAws_json1_1SetRepositoryPolicyCommand = async (output, context) => {
1023
+ if (output.statusCode >= 300) {
1024
+ return deserializeAws_json1_1SetRepositoryPolicyCommandError(output, context);
1025
+ }
1026
+ const data = await parseBody(output.body, context);
1027
+ let contents = {};
1028
+ contents = deserializeAws_json1_1SetRepositoryPolicyResponse(data, context);
1029
+ const response = {
1030
+ $metadata: deserializeMetadata(output),
1031
+ ...contents,
1032
+ };
1033
+ return Promise.resolve(response);
1034
+ };
1035
+ const deserializeAws_json1_1SetRepositoryPolicyCommandError = async (output, context) => {
1036
+ const parsedOutput = {
1037
+ ...output,
1038
+ body: await parseErrorBody(output.body, context),
1039
+ };
1040
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1041
+ switch (errorCode) {
1042
+ case "InvalidParameterException":
1043
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
1044
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1045
+ case "RepositoryNotFoundException":
1046
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
1047
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
1048
+ case "ServerException":
1049
+ case "com.amazonaws.ecrpublic#ServerException":
1050
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1051
+ default:
1052
+ const parsedBody = parsedOutput.body;
1053
+ throwDefaultError({
1054
+ output,
1055
+ parsedBody,
1056
+ exceptionCtor: __BaseException,
1057
+ errorCode,
1058
+ });
1059
+ }
1060
+ };
1061
+ export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
1062
+ if (output.statusCode >= 300) {
1063
+ return deserializeAws_json1_1TagResourceCommandError(output, context);
1064
+ }
1065
+ const data = await parseBody(output.body, context);
1066
+ let contents = {};
1067
+ contents = deserializeAws_json1_1TagResourceResponse(data, context);
1068
+ const response = {
1069
+ $metadata: deserializeMetadata(output),
1070
+ ...contents,
1071
+ };
1072
+ return Promise.resolve(response);
1073
+ };
1074
+ const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
1075
+ const parsedOutput = {
1076
+ ...output,
1077
+ body: await parseErrorBody(output.body, context),
1078
+ };
1079
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1080
+ switch (errorCode) {
1081
+ case "InvalidParameterException":
1082
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
1083
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1084
+ case "InvalidTagParameterException":
1085
+ case "com.amazonaws.ecrpublic#InvalidTagParameterException":
1086
+ throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
1087
+ case "RepositoryNotFoundException":
1088
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
1089
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
1090
+ case "ServerException":
1091
+ case "com.amazonaws.ecrpublic#ServerException":
1092
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1093
+ case "TooManyTagsException":
1094
+ case "com.amazonaws.ecrpublic#TooManyTagsException":
1095
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
1096
+ default:
1097
+ const parsedBody = parsedOutput.body;
1098
+ throwDefaultError({
1099
+ output,
1100
+ parsedBody,
1101
+ exceptionCtor: __BaseException,
1102
+ errorCode,
1103
+ });
1104
+ }
1105
+ };
1106
+ export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
1107
+ if (output.statusCode >= 300) {
1108
+ return deserializeAws_json1_1UntagResourceCommandError(output, context);
1109
+ }
1110
+ const data = await parseBody(output.body, context);
1111
+ let contents = {};
1112
+ contents = deserializeAws_json1_1UntagResourceResponse(data, context);
1113
+ const response = {
1114
+ $metadata: deserializeMetadata(output),
1115
+ ...contents,
1116
+ };
1117
+ return Promise.resolve(response);
1118
+ };
1119
+ const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
1120
+ const parsedOutput = {
1121
+ ...output,
1122
+ body: await parseErrorBody(output.body, context),
1123
+ };
1124
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1125
+ switch (errorCode) {
1126
+ case "InvalidParameterException":
1127
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
1128
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1129
+ case "InvalidTagParameterException":
1130
+ case "com.amazonaws.ecrpublic#InvalidTagParameterException":
1131
+ throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
1132
+ case "RepositoryNotFoundException":
1133
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
1134
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
1135
+ case "ServerException":
1136
+ case "com.amazonaws.ecrpublic#ServerException":
1137
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1138
+ case "TooManyTagsException":
1139
+ case "com.amazonaws.ecrpublic#TooManyTagsException":
1140
+ throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
1141
+ default:
1142
+ const parsedBody = parsedOutput.body;
1143
+ throwDefaultError({
1144
+ output,
1145
+ parsedBody,
1146
+ exceptionCtor: __BaseException,
1147
+ errorCode,
1148
+ });
1149
+ }
1150
+ };
1151
+ export const deserializeAws_json1_1UploadLayerPartCommand = async (output, context) => {
1152
+ if (output.statusCode >= 300) {
1153
+ return deserializeAws_json1_1UploadLayerPartCommandError(output, context);
1154
+ }
1155
+ const data = await parseBody(output.body, context);
1156
+ let contents = {};
1157
+ contents = deserializeAws_json1_1UploadLayerPartResponse(data, context);
1158
+ const response = {
1159
+ $metadata: deserializeMetadata(output),
1160
+ ...contents,
1161
+ };
1162
+ return Promise.resolve(response);
1163
+ };
1164
+ const deserializeAws_json1_1UploadLayerPartCommandError = async (output, context) => {
1165
+ const parsedOutput = {
1166
+ ...output,
1167
+ body: await parseErrorBody(output.body, context),
1168
+ };
1169
+ const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1170
+ switch (errorCode) {
1171
+ case "InvalidLayerPartException":
1172
+ case "com.amazonaws.ecrpublic#InvalidLayerPartException":
1173
+ throw await deserializeAws_json1_1InvalidLayerPartExceptionResponse(parsedOutput, context);
1174
+ case "InvalidParameterException":
1175
+ case "com.amazonaws.ecrpublic#InvalidParameterException":
1176
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1177
+ case "LimitExceededException":
1178
+ case "com.amazonaws.ecrpublic#LimitExceededException":
1179
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
1180
+ case "RegistryNotFoundException":
1181
+ case "com.amazonaws.ecrpublic#RegistryNotFoundException":
1182
+ throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
1183
+ case "RepositoryNotFoundException":
1184
+ case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
1185
+ throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
1186
+ case "ServerException":
1187
+ case "com.amazonaws.ecrpublic#ServerException":
1188
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1189
+ case "UnsupportedCommandException":
1190
+ case "com.amazonaws.ecrpublic#UnsupportedCommandException":
1191
+ throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
1192
+ case "UploadNotFoundException":
1193
+ case "com.amazonaws.ecrpublic#UploadNotFoundException":
1194
+ throw await deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context);
1195
+ default:
1196
+ const parsedBody = parsedOutput.body;
1197
+ throwDefaultError({
1198
+ output,
1199
+ parsedBody,
1200
+ exceptionCtor: __BaseException,
1201
+ errorCode,
1202
+ });
1203
+ }
1204
+ };
1205
+ const deserializeAws_json1_1EmptyUploadExceptionResponse = async (parsedOutput, context) => {
1206
+ const body = parsedOutput.body;
1207
+ const deserialized = deserializeAws_json1_1EmptyUploadException(body, context);
1208
+ const exception = new EmptyUploadException({
1209
+ $metadata: deserializeMetadata(parsedOutput),
1210
+ ...deserialized,
1211
+ });
1212
+ return __decorateServiceException(exception, body);
1213
+ };
1214
+ const deserializeAws_json1_1ImageAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
1215
+ const body = parsedOutput.body;
1216
+ const deserialized = deserializeAws_json1_1ImageAlreadyExistsException(body, context);
1217
+ const exception = new ImageAlreadyExistsException({
1218
+ $metadata: deserializeMetadata(parsedOutput),
1219
+ ...deserialized,
1220
+ });
1221
+ return __decorateServiceException(exception, body);
1222
+ };
1223
+ const deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse = async (parsedOutput, context) => {
1224
+ const body = parsedOutput.body;
1225
+ const deserialized = deserializeAws_json1_1ImageDigestDoesNotMatchException(body, context);
1226
+ const exception = new ImageDigestDoesNotMatchException({
1227
+ $metadata: deserializeMetadata(parsedOutput),
1228
+ ...deserialized,
1229
+ });
1230
+ return __decorateServiceException(exception, body);
1231
+ };
1232
+ const deserializeAws_json1_1ImageNotFoundExceptionResponse = async (parsedOutput, context) => {
1233
+ const body = parsedOutput.body;
1234
+ const deserialized = deserializeAws_json1_1ImageNotFoundException(body, context);
1235
+ const exception = new ImageNotFoundException({
1236
+ $metadata: deserializeMetadata(parsedOutput),
1237
+ ...deserialized,
1238
+ });
1239
+ return __decorateServiceException(exception, body);
1240
+ };
1241
+ const deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
1242
+ const body = parsedOutput.body;
1243
+ const deserialized = deserializeAws_json1_1ImageTagAlreadyExistsException(body, context);
1244
+ const exception = new ImageTagAlreadyExistsException({
1245
+ $metadata: deserializeMetadata(parsedOutput),
1246
+ ...deserialized,
1247
+ });
1248
+ return __decorateServiceException(exception, body);
1249
+ };
1250
+ const deserializeAws_json1_1InvalidLayerExceptionResponse = async (parsedOutput, context) => {
1251
+ const body = parsedOutput.body;
1252
+ const deserialized = deserializeAws_json1_1InvalidLayerException(body, context);
1253
+ const exception = new InvalidLayerException({
1254
+ $metadata: deserializeMetadata(parsedOutput),
1255
+ ...deserialized,
1256
+ });
1257
+ return __decorateServiceException(exception, body);
1258
+ };
1259
+ const deserializeAws_json1_1InvalidLayerPartExceptionResponse = async (parsedOutput, context) => {
1260
+ const body = parsedOutput.body;
1261
+ const deserialized = deserializeAws_json1_1InvalidLayerPartException(body, context);
1262
+ const exception = new InvalidLayerPartException({
1263
+ $metadata: deserializeMetadata(parsedOutput),
1264
+ ...deserialized,
1265
+ });
1266
+ return __decorateServiceException(exception, body);
1267
+ };
1268
+ const deserializeAws_json1_1InvalidParameterExceptionResponse = async (parsedOutput, context) => {
1269
+ const body = parsedOutput.body;
1270
+ const deserialized = deserializeAws_json1_1InvalidParameterException(body, context);
1271
+ const exception = new InvalidParameterException({
1272
+ $metadata: deserializeMetadata(parsedOutput),
1273
+ ...deserialized,
1274
+ });
1275
+ return __decorateServiceException(exception, body);
1276
+ };
1277
+ const deserializeAws_json1_1InvalidTagParameterExceptionResponse = async (parsedOutput, context) => {
1278
+ const body = parsedOutput.body;
1279
+ const deserialized = deserializeAws_json1_1InvalidTagParameterException(body, context);
1280
+ const exception = new InvalidTagParameterException({
1281
+ $metadata: deserializeMetadata(parsedOutput),
1282
+ ...deserialized,
1283
+ });
1284
+ return __decorateServiceException(exception, body);
1285
+ };
1286
+ const deserializeAws_json1_1LayerAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
1287
+ const body = parsedOutput.body;
1288
+ const deserialized = deserializeAws_json1_1LayerAlreadyExistsException(body, context);
1289
+ const exception = new LayerAlreadyExistsException({
1290
+ $metadata: deserializeMetadata(parsedOutput),
1291
+ ...deserialized,
1292
+ });
1293
+ return __decorateServiceException(exception, body);
1294
+ };
1295
+ const deserializeAws_json1_1LayerPartTooSmallExceptionResponse = async (parsedOutput, context) => {
1296
+ const body = parsedOutput.body;
1297
+ const deserialized = deserializeAws_json1_1LayerPartTooSmallException(body, context);
1298
+ const exception = new LayerPartTooSmallException({
1299
+ $metadata: deserializeMetadata(parsedOutput),
1300
+ ...deserialized,
1301
+ });
1302
+ return __decorateServiceException(exception, body);
1303
+ };
1304
+ const deserializeAws_json1_1LayersNotFoundExceptionResponse = async (parsedOutput, context) => {
1305
+ const body = parsedOutput.body;
1306
+ const deserialized = deserializeAws_json1_1LayersNotFoundException(body, context);
1307
+ const exception = new LayersNotFoundException({
1308
+ $metadata: deserializeMetadata(parsedOutput),
1309
+ ...deserialized,
1310
+ });
1311
+ return __decorateServiceException(exception, body);
1312
+ };
1313
+ const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
1314
+ const body = parsedOutput.body;
1315
+ const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
1316
+ const exception = new LimitExceededException({
1317
+ $metadata: deserializeMetadata(parsedOutput),
1318
+ ...deserialized,
1319
+ });
1320
+ return __decorateServiceException(exception, body);
1321
+ };
1322
+ const deserializeAws_json1_1ReferencedImagesNotFoundExceptionResponse = async (parsedOutput, context) => {
1323
+ const body = parsedOutput.body;
1324
+ const deserialized = deserializeAws_json1_1ReferencedImagesNotFoundException(body, context);
1325
+ const exception = new ReferencedImagesNotFoundException({
1326
+ $metadata: deserializeMetadata(parsedOutput),
1327
+ ...deserialized,
1328
+ });
1329
+ return __decorateServiceException(exception, body);
1330
+ };
1331
+ const deserializeAws_json1_1RegistryNotFoundExceptionResponse = async (parsedOutput, context) => {
1332
+ const body = parsedOutput.body;
1333
+ const deserialized = deserializeAws_json1_1RegistryNotFoundException(body, context);
1334
+ const exception = new RegistryNotFoundException({
1335
+ $metadata: deserializeMetadata(parsedOutput),
1336
+ ...deserialized,
1337
+ });
1338
+ return __decorateServiceException(exception, body);
1339
+ };
1340
+ const deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
1341
+ const body = parsedOutput.body;
1342
+ const deserialized = deserializeAws_json1_1RepositoryAlreadyExistsException(body, context);
1343
+ const exception = new RepositoryAlreadyExistsException({
1344
+ $metadata: deserializeMetadata(parsedOutput),
1345
+ ...deserialized,
1346
+ });
1347
+ return __decorateServiceException(exception, body);
1348
+ };
1349
+ const deserializeAws_json1_1RepositoryNotEmptyExceptionResponse = async (parsedOutput, context) => {
1350
+ const body = parsedOutput.body;
1351
+ const deserialized = deserializeAws_json1_1RepositoryNotEmptyException(body, context);
1352
+ const exception = new RepositoryNotEmptyException({
1353
+ $metadata: deserializeMetadata(parsedOutput),
1354
+ ...deserialized,
1355
+ });
1356
+ return __decorateServiceException(exception, body);
1357
+ };
1358
+ const deserializeAws_json1_1RepositoryNotFoundExceptionResponse = async (parsedOutput, context) => {
1359
+ const body = parsedOutput.body;
1360
+ const deserialized = deserializeAws_json1_1RepositoryNotFoundException(body, context);
1361
+ const exception = new RepositoryNotFoundException({
1362
+ $metadata: deserializeMetadata(parsedOutput),
1363
+ ...deserialized,
1364
+ });
1365
+ return __decorateServiceException(exception, body);
1366
+ };
1367
+ const deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
1368
+ const body = parsedOutput.body;
1369
+ const deserialized = deserializeAws_json1_1RepositoryPolicyNotFoundException(body, context);
1370
+ const exception = new RepositoryPolicyNotFoundException({
1371
+ $metadata: deserializeMetadata(parsedOutput),
1372
+ ...deserialized,
1373
+ });
1374
+ return __decorateServiceException(exception, body);
1375
+ };
1376
+ const deserializeAws_json1_1ServerExceptionResponse = async (parsedOutput, context) => {
1377
+ const body = parsedOutput.body;
1378
+ const deserialized = deserializeAws_json1_1ServerException(body, context);
1379
+ const exception = new ServerException({
1380
+ $metadata: deserializeMetadata(parsedOutput),
1381
+ ...deserialized,
1382
+ });
1383
+ return __decorateServiceException(exception, body);
1384
+ };
1385
+ const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
1386
+ const body = parsedOutput.body;
1387
+ const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
1388
+ const exception = new TooManyTagsException({
1389
+ $metadata: deserializeMetadata(parsedOutput),
1390
+ ...deserialized,
1391
+ });
1392
+ return __decorateServiceException(exception, body);
1393
+ };
1394
+ const deserializeAws_json1_1UnsupportedCommandExceptionResponse = async (parsedOutput, context) => {
1395
+ const body = parsedOutput.body;
1396
+ const deserialized = deserializeAws_json1_1UnsupportedCommandException(body, context);
1397
+ const exception = new UnsupportedCommandException({
1398
+ $metadata: deserializeMetadata(parsedOutput),
1399
+ ...deserialized,
1400
+ });
1401
+ return __decorateServiceException(exception, body);
1402
+ };
1403
+ const deserializeAws_json1_1UploadNotFoundExceptionResponse = async (parsedOutput, context) => {
1404
+ const body = parsedOutput.body;
1405
+ const deserialized = deserializeAws_json1_1UploadNotFoundException(body, context);
1406
+ const exception = new UploadNotFoundException({
1407
+ $metadata: deserializeMetadata(parsedOutput),
1408
+ ...deserialized,
1409
+ });
1410
+ return __decorateServiceException(exception, body);
1411
+ };
1412
+ const serializeAws_json1_1ArchitectureList = (input, context) => {
1952
1413
  return input
1953
- .filter(function (e) { return e != null; })
1954
- .map(function (entry) {
1414
+ .filter((e) => e != null)
1415
+ .map((entry) => {
1955
1416
  return entry;
1956
1417
  });
1957
1418
  };
1958
- var serializeAws_json1_1BatchCheckLayerAvailabilityRequest = function (input, context) {
1959
- return __assign(__assign(__assign({}, (input.layerDigests != null && {
1960
- layerDigests: serializeAws_json1_1BatchedOperationLayerDigestList(input.layerDigests, context),
1961
- })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1419
+ const serializeAws_json1_1BatchCheckLayerAvailabilityRequest = (input, context) => {
1420
+ return {
1421
+ ...(input.layerDigests != null && {
1422
+ layerDigests: serializeAws_json1_1BatchedOperationLayerDigestList(input.layerDigests, context),
1423
+ }),
1424
+ ...(input.registryId != null && { registryId: input.registryId }),
1425
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1426
+ };
1962
1427
  };
1963
- var serializeAws_json1_1BatchDeleteImageRequest = function (input, context) {
1964
- return __assign(__assign(__assign({}, (input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1428
+ const serializeAws_json1_1BatchDeleteImageRequest = (input, context) => {
1429
+ return {
1430
+ ...(input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) }),
1431
+ ...(input.registryId != null && { registryId: input.registryId }),
1432
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1433
+ };
1965
1434
  };
1966
- var serializeAws_json1_1BatchedOperationLayerDigestList = function (input, context) {
1435
+ const serializeAws_json1_1BatchedOperationLayerDigestList = (input, context) => {
1967
1436
  return input
1968
- .filter(function (e) { return e != null; })
1969
- .map(function (entry) {
1437
+ .filter((e) => e != null)
1438
+ .map((entry) => {
1970
1439
  return entry;
1971
1440
  });
1972
1441
  };
1973
- var serializeAws_json1_1CompleteLayerUploadRequest = function (input, context) {
1974
- return __assign(__assign(__assign(__assign({}, (input.layerDigests != null && {
1975
- layerDigests: serializeAws_json1_1LayerDigestList(input.layerDigests, context),
1976
- })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName })), (input.uploadId != null && { uploadId: input.uploadId }));
1442
+ const serializeAws_json1_1CompleteLayerUploadRequest = (input, context) => {
1443
+ return {
1444
+ ...(input.layerDigests != null && {
1445
+ layerDigests: serializeAws_json1_1LayerDigestList(input.layerDigests, context),
1446
+ }),
1447
+ ...(input.registryId != null && { registryId: input.registryId }),
1448
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1449
+ ...(input.uploadId != null && { uploadId: input.uploadId }),
1450
+ };
1977
1451
  };
1978
- var serializeAws_json1_1CreateRepositoryRequest = function (input, context) {
1979
- return __assign(__assign(__assign({}, (input.catalogData != null && {
1980
- catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
1981
- })), (input.repositoryName != null && { repositoryName: input.repositoryName })), (input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }));
1452
+ const serializeAws_json1_1CreateRepositoryRequest = (input, context) => {
1453
+ return {
1454
+ ...(input.catalogData != null && {
1455
+ catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
1456
+ }),
1457
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1458
+ ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
1459
+ };
1982
1460
  };
1983
- var serializeAws_json1_1DeleteRepositoryPolicyRequest = function (input, context) {
1984
- return __assign(__assign({}, (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1461
+ const serializeAws_json1_1DeleteRepositoryPolicyRequest = (input, context) => {
1462
+ return {
1463
+ ...(input.registryId != null && { registryId: input.registryId }),
1464
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1465
+ };
1985
1466
  };
1986
- var serializeAws_json1_1DeleteRepositoryRequest = function (input, context) {
1987
- return __assign(__assign(__assign({}, (input.force != null && { force: input.force })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1467
+ const serializeAws_json1_1DeleteRepositoryRequest = (input, context) => {
1468
+ return {
1469
+ ...(input.force != null && { force: input.force }),
1470
+ ...(input.registryId != null && { registryId: input.registryId }),
1471
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1472
+ };
1988
1473
  };
1989
- var serializeAws_json1_1DescribeImagesRequest = function (input, context) {
1990
- return __assign(__assign(__assign(__assign(__assign({}, (input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) })), (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1474
+ const serializeAws_json1_1DescribeImagesRequest = (input, context) => {
1475
+ return {
1476
+ ...(input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) }),
1477
+ ...(input.maxResults != null && { maxResults: input.maxResults }),
1478
+ ...(input.nextToken != null && { nextToken: input.nextToken }),
1479
+ ...(input.registryId != null && { registryId: input.registryId }),
1480
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1481
+ };
1991
1482
  };
1992
- var serializeAws_json1_1DescribeImageTagsRequest = function (input, context) {
1993
- return __assign(__assign(__assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1483
+ const serializeAws_json1_1DescribeImageTagsRequest = (input, context) => {
1484
+ return {
1485
+ ...(input.maxResults != null && { maxResults: input.maxResults }),
1486
+ ...(input.nextToken != null && { nextToken: input.nextToken }),
1487
+ ...(input.registryId != null && { registryId: input.registryId }),
1488
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1489
+ };
1994
1490
  };
1995
- var serializeAws_json1_1DescribeRegistriesRequest = function (input, context) {
1996
- return __assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken }));
1491
+ const serializeAws_json1_1DescribeRegistriesRequest = (input, context) => {
1492
+ return {
1493
+ ...(input.maxResults != null && { maxResults: input.maxResults }),
1494
+ ...(input.nextToken != null && { nextToken: input.nextToken }),
1495
+ };
1997
1496
  };
1998
- var serializeAws_json1_1DescribeRepositoriesRequest = function (input, context) {
1999
- return __assign(__assign(__assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryNames != null && {
2000
- repositoryNames: serializeAws_json1_1RepositoryNameList(input.repositoryNames, context),
2001
- }));
1497
+ const serializeAws_json1_1DescribeRepositoriesRequest = (input, context) => {
1498
+ return {
1499
+ ...(input.maxResults != null && { maxResults: input.maxResults }),
1500
+ ...(input.nextToken != null && { nextToken: input.nextToken }),
1501
+ ...(input.registryId != null && { registryId: input.registryId }),
1502
+ ...(input.repositoryNames != null && {
1503
+ repositoryNames: serializeAws_json1_1RepositoryNameList(input.repositoryNames, context),
1504
+ }),
1505
+ };
2002
1506
  };
2003
- var serializeAws_json1_1GetAuthorizationTokenRequest = function (input, context) {
1507
+ const serializeAws_json1_1GetAuthorizationTokenRequest = (input, context) => {
2004
1508
  return {};
2005
1509
  };
2006
- var serializeAws_json1_1GetRegistryCatalogDataRequest = function (input, context) {
1510
+ const serializeAws_json1_1GetRegistryCatalogDataRequest = (input, context) => {
2007
1511
  return {};
2008
1512
  };
2009
- var serializeAws_json1_1GetRepositoryCatalogDataRequest = function (input, context) {
2010
- return __assign(__assign({}, (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1513
+ const serializeAws_json1_1GetRepositoryCatalogDataRequest = (input, context) => {
1514
+ return {
1515
+ ...(input.registryId != null && { registryId: input.registryId }),
1516
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1517
+ };
2011
1518
  };
2012
- var serializeAws_json1_1GetRepositoryPolicyRequest = function (input, context) {
2013
- return __assign(__assign({}, (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1519
+ const serializeAws_json1_1GetRepositoryPolicyRequest = (input, context) => {
1520
+ return {
1521
+ ...(input.registryId != null && { registryId: input.registryId }),
1522
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1523
+ };
2014
1524
  };
2015
- var serializeAws_json1_1ImageIdentifier = function (input, context) {
2016
- return __assign(__assign({}, (input.imageDigest != null && { imageDigest: input.imageDigest })), (input.imageTag != null && { imageTag: input.imageTag }));
1525
+ const serializeAws_json1_1ImageIdentifier = (input, context) => {
1526
+ return {
1527
+ ...(input.imageDigest != null && { imageDigest: input.imageDigest }),
1528
+ ...(input.imageTag != null && { imageTag: input.imageTag }),
1529
+ };
2017
1530
  };
2018
- var serializeAws_json1_1ImageIdentifierList = function (input, context) {
1531
+ const serializeAws_json1_1ImageIdentifierList = (input, context) => {
2019
1532
  return input
2020
- .filter(function (e) { return e != null; })
2021
- .map(function (entry) {
1533
+ .filter((e) => e != null)
1534
+ .map((entry) => {
2022
1535
  return serializeAws_json1_1ImageIdentifier(entry, context);
2023
1536
  });
2024
1537
  };
2025
- var serializeAws_json1_1InitiateLayerUploadRequest = function (input, context) {
2026
- return __assign(__assign({}, (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1538
+ const serializeAws_json1_1InitiateLayerUploadRequest = (input, context) => {
1539
+ return {
1540
+ ...(input.registryId != null && { registryId: input.registryId }),
1541
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1542
+ };
2027
1543
  };
2028
- var serializeAws_json1_1LayerDigestList = function (input, context) {
1544
+ const serializeAws_json1_1LayerDigestList = (input, context) => {
2029
1545
  return input
2030
- .filter(function (e) { return e != null; })
2031
- .map(function (entry) {
1546
+ .filter((e) => e != null)
1547
+ .map((entry) => {
2032
1548
  return entry;
2033
1549
  });
2034
1550
  };
2035
- var serializeAws_json1_1ListTagsForResourceRequest = function (input, context) {
2036
- return __assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn }));
1551
+ const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
1552
+ return {
1553
+ ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
1554
+ };
2037
1555
  };
2038
- var serializeAws_json1_1OperatingSystemList = function (input, context) {
1556
+ const serializeAws_json1_1OperatingSystemList = (input, context) => {
2039
1557
  return input
2040
- .filter(function (e) { return e != null; })
2041
- .map(function (entry) {
1558
+ .filter((e) => e != null)
1559
+ .map((entry) => {
2042
1560
  return entry;
2043
1561
  });
2044
1562
  };
2045
- var serializeAws_json1_1PutImageRequest = function (input, context) {
2046
- return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.imageDigest != null && { imageDigest: input.imageDigest })), (input.imageManifest != null && { imageManifest: input.imageManifest })), (input.imageManifestMediaType != null && { imageManifestMediaType: input.imageManifestMediaType })), (input.imageTag != null && { imageTag: input.imageTag })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1563
+ const serializeAws_json1_1PutImageRequest = (input, context) => {
1564
+ return {
1565
+ ...(input.imageDigest != null && { imageDigest: input.imageDigest }),
1566
+ ...(input.imageManifest != null && { imageManifest: input.imageManifest }),
1567
+ ...(input.imageManifestMediaType != null && { imageManifestMediaType: input.imageManifestMediaType }),
1568
+ ...(input.imageTag != null && { imageTag: input.imageTag }),
1569
+ ...(input.registryId != null && { registryId: input.registryId }),
1570
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1571
+ };
2047
1572
  };
2048
- var serializeAws_json1_1PutRegistryCatalogDataRequest = function (input, context) {
2049
- return __assign({}, (input.displayName != null && { displayName: input.displayName }));
1573
+ const serializeAws_json1_1PutRegistryCatalogDataRequest = (input, context) => {
1574
+ return {
1575
+ ...(input.displayName != null && { displayName: input.displayName }),
1576
+ };
2050
1577
  };
2051
- var serializeAws_json1_1PutRepositoryCatalogDataRequest = function (input, context) {
2052
- return __assign(__assign(__assign({}, (input.catalogData != null && {
2053
- catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
2054
- })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1578
+ const serializeAws_json1_1PutRepositoryCatalogDataRequest = (input, context) => {
1579
+ return {
1580
+ ...(input.catalogData != null && {
1581
+ catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
1582
+ }),
1583
+ ...(input.registryId != null && { registryId: input.registryId }),
1584
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1585
+ };
2055
1586
  };
2056
- var serializeAws_json1_1RepositoryCatalogDataInput = function (input, context) {
2057
- return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.aboutText != null && { aboutText: input.aboutText })), (input.architectures != null && {
2058
- architectures: serializeAws_json1_1ArchitectureList(input.architectures, context),
2059
- })), (input.description != null && { description: input.description })), (input.logoImageBlob != null && { logoImageBlob: context.base64Encoder(input.logoImageBlob) })), (input.operatingSystems != null && {
2060
- operatingSystems: serializeAws_json1_1OperatingSystemList(input.operatingSystems, context),
2061
- })), (input.usageText != null && { usageText: input.usageText }));
1587
+ const serializeAws_json1_1RepositoryCatalogDataInput = (input, context) => {
1588
+ return {
1589
+ ...(input.aboutText != null && { aboutText: input.aboutText }),
1590
+ ...(input.architectures != null && {
1591
+ architectures: serializeAws_json1_1ArchitectureList(input.architectures, context),
1592
+ }),
1593
+ ...(input.description != null && { description: input.description }),
1594
+ ...(input.logoImageBlob != null && { logoImageBlob: context.base64Encoder(input.logoImageBlob) }),
1595
+ ...(input.operatingSystems != null && {
1596
+ operatingSystems: serializeAws_json1_1OperatingSystemList(input.operatingSystems, context),
1597
+ }),
1598
+ ...(input.usageText != null && { usageText: input.usageText }),
1599
+ };
2062
1600
  };
2063
- var serializeAws_json1_1RepositoryNameList = function (input, context) {
1601
+ const serializeAws_json1_1RepositoryNameList = (input, context) => {
2064
1602
  return input
2065
- .filter(function (e) { return e != null; })
2066
- .map(function (entry) {
1603
+ .filter((e) => e != null)
1604
+ .map((entry) => {
2067
1605
  return entry;
2068
1606
  });
2069
1607
  };
2070
- var serializeAws_json1_1SetRepositoryPolicyRequest = function (input, context) {
2071
- return __assign(__assign(__assign(__assign({}, (input.force != null && { force: input.force })), (input.policyText != null && { policyText: input.policyText })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName }));
1608
+ const serializeAws_json1_1SetRepositoryPolicyRequest = (input, context) => {
1609
+ return {
1610
+ ...(input.force != null && { force: input.force }),
1611
+ ...(input.policyText != null && { policyText: input.policyText }),
1612
+ ...(input.registryId != null && { registryId: input.registryId }),
1613
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1614
+ };
2072
1615
  };
2073
- var serializeAws_json1_1Tag = function (input, context) {
2074
- return __assign(__assign({}, (input.Key != null && { Key: input.Key })), (input.Value != null && { Value: input.Value }));
1616
+ const serializeAws_json1_1Tag = (input, context) => {
1617
+ return {
1618
+ ...(input.Key != null && { Key: input.Key }),
1619
+ ...(input.Value != null && { Value: input.Value }),
1620
+ };
2075
1621
  };
2076
- var serializeAws_json1_1TagKeyList = function (input, context) {
1622
+ const serializeAws_json1_1TagKeyList = (input, context) => {
2077
1623
  return input
2078
- .filter(function (e) { return e != null; })
2079
- .map(function (entry) {
1624
+ .filter((e) => e != null)
1625
+ .map((entry) => {
2080
1626
  return entry;
2081
1627
  });
2082
1628
  };
2083
- var serializeAws_json1_1TagList = function (input, context) {
1629
+ const serializeAws_json1_1TagList = (input, context) => {
2084
1630
  return input
2085
- .filter(function (e) { return e != null; })
2086
- .map(function (entry) {
1631
+ .filter((e) => e != null)
1632
+ .map((entry) => {
2087
1633
  return serializeAws_json1_1Tag(entry, context);
2088
1634
  });
2089
1635
  };
2090
- var serializeAws_json1_1TagResourceRequest = function (input, context) {
2091
- return __assign(__assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn })), (input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }));
1636
+ const serializeAws_json1_1TagResourceRequest = (input, context) => {
1637
+ return {
1638
+ ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
1639
+ ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
1640
+ };
2092
1641
  };
2093
- var serializeAws_json1_1UntagResourceRequest = function (input, context) {
2094
- return __assign(__assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn })), (input.tagKeys != null && { tagKeys: serializeAws_json1_1TagKeyList(input.tagKeys, context) }));
1642
+ const serializeAws_json1_1UntagResourceRequest = (input, context) => {
1643
+ return {
1644
+ ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
1645
+ ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1TagKeyList(input.tagKeys, context) }),
1646
+ };
2095
1647
  };
2096
- var serializeAws_json1_1UploadLayerPartRequest = function (input, context) {
2097
- return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.layerPartBlob != null && { layerPartBlob: context.base64Encoder(input.layerPartBlob) })), (input.partFirstByte != null && { partFirstByte: input.partFirstByte })), (input.partLastByte != null && { partLastByte: input.partLastByte })), (input.registryId != null && { registryId: input.registryId })), (input.repositoryName != null && { repositoryName: input.repositoryName })), (input.uploadId != null && { uploadId: input.uploadId }));
1648
+ const serializeAws_json1_1UploadLayerPartRequest = (input, context) => {
1649
+ return {
1650
+ ...(input.layerPartBlob != null && { layerPartBlob: context.base64Encoder(input.layerPartBlob) }),
1651
+ ...(input.partFirstByte != null && { partFirstByte: input.partFirstByte }),
1652
+ ...(input.partLastByte != null && { partLastByte: input.partLastByte }),
1653
+ ...(input.registryId != null && { registryId: input.registryId }),
1654
+ ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
1655
+ ...(input.uploadId != null && { uploadId: input.uploadId }),
1656
+ };
2098
1657
  };
2099
- var deserializeAws_json1_1ArchitectureList = function (output, context) {
2100
- var retVal = (output || [])
2101
- .filter(function (e) { return e != null; })
2102
- .map(function (entry) {
1658
+ const deserializeAws_json1_1ArchitectureList = (output, context) => {
1659
+ const retVal = (output || [])
1660
+ .filter((e) => e != null)
1661
+ .map((entry) => {
2103
1662
  if (entry === null) {
2104
1663
  return null;
2105
1664
  }
@@ -2107,25 +1666,25 @@ var deserializeAws_json1_1ArchitectureList = function (output, context) {
2107
1666
  });
2108
1667
  return retVal;
2109
1668
  };
2110
- var deserializeAws_json1_1AuthorizationData = function (output, context) {
1669
+ const deserializeAws_json1_1AuthorizationData = (output, context) => {
2111
1670
  return {
2112
1671
  authorizationToken: __expectString(output.authorizationToken),
2113
1672
  expiresAt: output.expiresAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.expiresAt))) : undefined,
2114
1673
  };
2115
1674
  };
2116
- var deserializeAws_json1_1BatchCheckLayerAvailabilityResponse = function (output, context) {
1675
+ const deserializeAws_json1_1BatchCheckLayerAvailabilityResponse = (output, context) => {
2117
1676
  return {
2118
1677
  failures: output.failures != null ? deserializeAws_json1_1LayerFailureList(output.failures, context) : undefined,
2119
1678
  layers: output.layers != null ? deserializeAws_json1_1LayerList(output.layers, context) : undefined,
2120
1679
  };
2121
1680
  };
2122
- var deserializeAws_json1_1BatchDeleteImageResponse = function (output, context) {
1681
+ const deserializeAws_json1_1BatchDeleteImageResponse = (output, context) => {
2123
1682
  return {
2124
1683
  failures: output.failures != null ? deserializeAws_json1_1ImageFailureList(output.failures, context) : undefined,
2125
1684
  imageIds: output.imageIds != null ? deserializeAws_json1_1ImageIdentifierList(output.imageIds, context) : undefined,
2126
1685
  };
2127
1686
  };
2128
- var deserializeAws_json1_1CompleteLayerUploadResponse = function (output, context) {
1687
+ const deserializeAws_json1_1CompleteLayerUploadResponse = (output, context) => {
2129
1688
  return {
2130
1689
  layerDigest: __expectString(output.layerDigest),
2131
1690
  registryId: __expectString(output.registryId),
@@ -2133,31 +1692,31 @@ var deserializeAws_json1_1CompleteLayerUploadResponse = function (output, contex
2133
1692
  uploadId: __expectString(output.uploadId),
2134
1693
  };
2135
1694
  };
2136
- var deserializeAws_json1_1CreateRepositoryResponse = function (output, context) {
1695
+ const deserializeAws_json1_1CreateRepositoryResponse = (output, context) => {
2137
1696
  return {
2138
1697
  catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
2139
1698
  repository: output.repository != null ? deserializeAws_json1_1Repository(output.repository, context) : undefined,
2140
1699
  };
2141
1700
  };
2142
- var deserializeAws_json1_1DeleteRepositoryPolicyResponse = function (output, context) {
1701
+ const deserializeAws_json1_1DeleteRepositoryPolicyResponse = (output, context) => {
2143
1702
  return {
2144
1703
  policyText: __expectString(output.policyText),
2145
1704
  registryId: __expectString(output.registryId),
2146
1705
  repositoryName: __expectString(output.repositoryName),
2147
1706
  };
2148
1707
  };
2149
- var deserializeAws_json1_1DeleteRepositoryResponse = function (output, context) {
1708
+ const deserializeAws_json1_1DeleteRepositoryResponse = (output, context) => {
2150
1709
  return {
2151
1710
  repository: output.repository != null ? deserializeAws_json1_1Repository(output.repository, context) : undefined,
2152
1711
  };
2153
1712
  };
2154
- var deserializeAws_json1_1DescribeImagesResponse = function (output, context) {
1713
+ const deserializeAws_json1_1DescribeImagesResponse = (output, context) => {
2155
1714
  return {
2156
1715
  imageDetails: output.imageDetails != null ? deserializeAws_json1_1ImageDetailList(output.imageDetails, context) : undefined,
2157
1716
  nextToken: __expectString(output.nextToken),
2158
1717
  };
2159
1718
  };
2160
- var deserializeAws_json1_1DescribeImageTagsResponse = function (output, context) {
1719
+ const deserializeAws_json1_1DescribeImageTagsResponse = (output, context) => {
2161
1720
  return {
2162
1721
  imageTagDetails: output.imageTagDetails != null
2163
1722
  ? deserializeAws_json1_1ImageTagDetailList(output.imageTagDetails, context)
@@ -2165,50 +1724,50 @@ var deserializeAws_json1_1DescribeImageTagsResponse = function (output, context)
2165
1724
  nextToken: __expectString(output.nextToken),
2166
1725
  };
2167
1726
  };
2168
- var deserializeAws_json1_1DescribeRegistriesResponse = function (output, context) {
1727
+ const deserializeAws_json1_1DescribeRegistriesResponse = (output, context) => {
2169
1728
  return {
2170
1729
  nextToken: __expectString(output.nextToken),
2171
1730
  registries: output.registries != null ? deserializeAws_json1_1RegistryList(output.registries, context) : undefined,
2172
1731
  };
2173
1732
  };
2174
- var deserializeAws_json1_1DescribeRepositoriesResponse = function (output, context) {
1733
+ const deserializeAws_json1_1DescribeRepositoriesResponse = (output, context) => {
2175
1734
  return {
2176
1735
  nextToken: __expectString(output.nextToken),
2177
1736
  repositories: output.repositories != null ? deserializeAws_json1_1RepositoryList(output.repositories, context) : undefined,
2178
1737
  };
2179
1738
  };
2180
- var deserializeAws_json1_1EmptyUploadException = function (output, context) {
1739
+ const deserializeAws_json1_1EmptyUploadException = (output, context) => {
2181
1740
  return {
2182
1741
  message: __expectString(output.message),
2183
1742
  };
2184
1743
  };
2185
- var deserializeAws_json1_1GetAuthorizationTokenResponse = function (output, context) {
1744
+ const deserializeAws_json1_1GetAuthorizationTokenResponse = (output, context) => {
2186
1745
  return {
2187
1746
  authorizationData: output.authorizationData != null
2188
1747
  ? deserializeAws_json1_1AuthorizationData(output.authorizationData, context)
2189
1748
  : undefined,
2190
1749
  };
2191
1750
  };
2192
- var deserializeAws_json1_1GetRegistryCatalogDataResponse = function (output, context) {
1751
+ const deserializeAws_json1_1GetRegistryCatalogDataResponse = (output, context) => {
2193
1752
  return {
2194
1753
  registryCatalogData: output.registryCatalogData != null
2195
1754
  ? deserializeAws_json1_1RegistryCatalogData(output.registryCatalogData, context)
2196
1755
  : undefined,
2197
1756
  };
2198
1757
  };
2199
- var deserializeAws_json1_1GetRepositoryCatalogDataResponse = function (output, context) {
1758
+ const deserializeAws_json1_1GetRepositoryCatalogDataResponse = (output, context) => {
2200
1759
  return {
2201
1760
  catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
2202
1761
  };
2203
1762
  };
2204
- var deserializeAws_json1_1GetRepositoryPolicyResponse = function (output, context) {
1763
+ const deserializeAws_json1_1GetRepositoryPolicyResponse = (output, context) => {
2205
1764
  return {
2206
1765
  policyText: __expectString(output.policyText),
2207
1766
  registryId: __expectString(output.registryId),
2208
1767
  repositoryName: __expectString(output.repositoryName),
2209
1768
  };
2210
1769
  };
2211
- var deserializeAws_json1_1Image = function (output, context) {
1770
+ const deserializeAws_json1_1Image = (output, context) => {
2212
1771
  return {
2213
1772
  imageId: output.imageId != null ? deserializeAws_json1_1ImageIdentifier(output.imageId, context) : undefined,
2214
1773
  imageManifest: __expectString(output.imageManifest),
@@ -2217,12 +1776,12 @@ var deserializeAws_json1_1Image = function (output, context) {
2217
1776
  repositoryName: __expectString(output.repositoryName),
2218
1777
  };
2219
1778
  };
2220
- var deserializeAws_json1_1ImageAlreadyExistsException = function (output, context) {
1779
+ const deserializeAws_json1_1ImageAlreadyExistsException = (output, context) => {
2221
1780
  return {
2222
1781
  message: __expectString(output.message),
2223
1782
  };
2224
1783
  };
2225
- var deserializeAws_json1_1ImageDetail = function (output, context) {
1784
+ const deserializeAws_json1_1ImageDetail = (output, context) => {
2226
1785
  return {
2227
1786
  artifactMediaType: __expectString(output.artifactMediaType),
2228
1787
  imageDigest: __expectString(output.imageDigest),
@@ -2236,10 +1795,10 @@ var deserializeAws_json1_1ImageDetail = function (output, context) {
2236
1795
  repositoryName: __expectString(output.repositoryName),
2237
1796
  };
2238
1797
  };
2239
- var deserializeAws_json1_1ImageDetailList = function (output, context) {
2240
- var retVal = (output || [])
2241
- .filter(function (e) { return e != null; })
2242
- .map(function (entry) {
1798
+ const deserializeAws_json1_1ImageDetailList = (output, context) => {
1799
+ const retVal = (output || [])
1800
+ .filter((e) => e != null)
1801
+ .map((entry) => {
2243
1802
  if (entry === null) {
2244
1803
  return null;
2245
1804
  }
@@ -2247,22 +1806,22 @@ var deserializeAws_json1_1ImageDetailList = function (output, context) {
2247
1806
  });
2248
1807
  return retVal;
2249
1808
  };
2250
- var deserializeAws_json1_1ImageDigestDoesNotMatchException = function (output, context) {
1809
+ const deserializeAws_json1_1ImageDigestDoesNotMatchException = (output, context) => {
2251
1810
  return {
2252
1811
  message: __expectString(output.message),
2253
1812
  };
2254
1813
  };
2255
- var deserializeAws_json1_1ImageFailure = function (output, context) {
1814
+ const deserializeAws_json1_1ImageFailure = (output, context) => {
2256
1815
  return {
2257
1816
  failureCode: __expectString(output.failureCode),
2258
1817
  failureReason: __expectString(output.failureReason),
2259
1818
  imageId: output.imageId != null ? deserializeAws_json1_1ImageIdentifier(output.imageId, context) : undefined,
2260
1819
  };
2261
1820
  };
2262
- var deserializeAws_json1_1ImageFailureList = function (output, context) {
2263
- var retVal = (output || [])
2264
- .filter(function (e) { return e != null; })
2265
- .map(function (entry) {
1821
+ const deserializeAws_json1_1ImageFailureList = (output, context) => {
1822
+ const retVal = (output || [])
1823
+ .filter((e) => e != null)
1824
+ .map((entry) => {
2266
1825
  if (entry === null) {
2267
1826
  return null;
2268
1827
  }
@@ -2270,16 +1829,16 @@ var deserializeAws_json1_1ImageFailureList = function (output, context) {
2270
1829
  });
2271
1830
  return retVal;
2272
1831
  };
2273
- var deserializeAws_json1_1ImageIdentifier = function (output, context) {
1832
+ const deserializeAws_json1_1ImageIdentifier = (output, context) => {
2274
1833
  return {
2275
1834
  imageDigest: __expectString(output.imageDigest),
2276
1835
  imageTag: __expectString(output.imageTag),
2277
1836
  };
2278
1837
  };
2279
- var deserializeAws_json1_1ImageIdentifierList = function (output, context) {
2280
- var retVal = (output || [])
2281
- .filter(function (e) { return e != null; })
2282
- .map(function (entry) {
1838
+ const deserializeAws_json1_1ImageIdentifierList = (output, context) => {
1839
+ const retVal = (output || [])
1840
+ .filter((e) => e != null)
1841
+ .map((entry) => {
2283
1842
  if (entry === null) {
2284
1843
  return null;
2285
1844
  }
@@ -2287,27 +1846,27 @@ var deserializeAws_json1_1ImageIdentifierList = function (output, context) {
2287
1846
  });
2288
1847
  return retVal;
2289
1848
  };
2290
- var deserializeAws_json1_1ImageNotFoundException = function (output, context) {
1849
+ const deserializeAws_json1_1ImageNotFoundException = (output, context) => {
2291
1850
  return {
2292
1851
  message: __expectString(output.message),
2293
1852
  };
2294
1853
  };
2295
- var deserializeAws_json1_1ImageTagAlreadyExistsException = function (output, context) {
1854
+ const deserializeAws_json1_1ImageTagAlreadyExistsException = (output, context) => {
2296
1855
  return {
2297
1856
  message: __expectString(output.message),
2298
1857
  };
2299
1858
  };
2300
- var deserializeAws_json1_1ImageTagDetail = function (output, context) {
1859
+ const deserializeAws_json1_1ImageTagDetail = (output, context) => {
2301
1860
  return {
2302
1861
  createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
2303
1862
  imageDetail: output.imageDetail != null ? deserializeAws_json1_1ReferencedImageDetail(output.imageDetail, context) : undefined,
2304
1863
  imageTag: __expectString(output.imageTag),
2305
1864
  };
2306
1865
  };
2307
- var deserializeAws_json1_1ImageTagDetailList = function (output, context) {
2308
- var retVal = (output || [])
2309
- .filter(function (e) { return e != null; })
2310
- .map(function (entry) {
1866
+ const deserializeAws_json1_1ImageTagDetailList = (output, context) => {
1867
+ const retVal = (output || [])
1868
+ .filter((e) => e != null)
1869
+ .map((entry) => {
2311
1870
  if (entry === null) {
2312
1871
  return null;
2313
1872
  }
@@ -2315,10 +1874,10 @@ var deserializeAws_json1_1ImageTagDetailList = function (output, context) {
2315
1874
  });
2316
1875
  return retVal;
2317
1876
  };
2318
- var deserializeAws_json1_1ImageTagList = function (output, context) {
2319
- var retVal = (output || [])
2320
- .filter(function (e) { return e != null; })
2321
- .map(function (entry) {
1877
+ const deserializeAws_json1_1ImageTagList = (output, context) => {
1878
+ const retVal = (output || [])
1879
+ .filter((e) => e != null)
1880
+ .map((entry) => {
2322
1881
  if (entry === null) {
2323
1882
  return null;
2324
1883
  }
@@ -2326,18 +1885,18 @@ var deserializeAws_json1_1ImageTagList = function (output, context) {
2326
1885
  });
2327
1886
  return retVal;
2328
1887
  };
2329
- var deserializeAws_json1_1InitiateLayerUploadResponse = function (output, context) {
1888
+ const deserializeAws_json1_1InitiateLayerUploadResponse = (output, context) => {
2330
1889
  return {
2331
1890
  partSize: __expectLong(output.partSize),
2332
1891
  uploadId: __expectString(output.uploadId),
2333
1892
  };
2334
1893
  };
2335
- var deserializeAws_json1_1InvalidLayerException = function (output, context) {
1894
+ const deserializeAws_json1_1InvalidLayerException = (output, context) => {
2336
1895
  return {
2337
1896
  message: __expectString(output.message),
2338
1897
  };
2339
1898
  };
2340
- var deserializeAws_json1_1InvalidLayerPartException = function (output, context) {
1899
+ const deserializeAws_json1_1InvalidLayerPartException = (output, context) => {
2341
1900
  return {
2342
1901
  lastValidByteReceived: __expectLong(output.lastValidByteReceived),
2343
1902
  message: __expectString(output.message),
@@ -2346,17 +1905,17 @@ var deserializeAws_json1_1InvalidLayerPartException = function (output, context)
2346
1905
  uploadId: __expectString(output.uploadId),
2347
1906
  };
2348
1907
  };
2349
- var deserializeAws_json1_1InvalidParameterException = function (output, context) {
1908
+ const deserializeAws_json1_1InvalidParameterException = (output, context) => {
2350
1909
  return {
2351
1910
  message: __expectString(output.message),
2352
1911
  };
2353
1912
  };
2354
- var deserializeAws_json1_1InvalidTagParameterException = function (output, context) {
1913
+ const deserializeAws_json1_1InvalidTagParameterException = (output, context) => {
2355
1914
  return {
2356
1915
  message: __expectString(output.message),
2357
1916
  };
2358
1917
  };
2359
- var deserializeAws_json1_1Layer = function (output, context) {
1918
+ const deserializeAws_json1_1Layer = (output, context) => {
2360
1919
  return {
2361
1920
  layerAvailability: __expectString(output.layerAvailability),
2362
1921
  layerDigest: __expectString(output.layerDigest),
@@ -2364,22 +1923,22 @@ var deserializeAws_json1_1Layer = function (output, context) {
2364
1923
  mediaType: __expectString(output.mediaType),
2365
1924
  };
2366
1925
  };
2367
- var deserializeAws_json1_1LayerAlreadyExistsException = function (output, context) {
1926
+ const deserializeAws_json1_1LayerAlreadyExistsException = (output, context) => {
2368
1927
  return {
2369
1928
  message: __expectString(output.message),
2370
1929
  };
2371
1930
  };
2372
- var deserializeAws_json1_1LayerFailure = function (output, context) {
1931
+ const deserializeAws_json1_1LayerFailure = (output, context) => {
2373
1932
  return {
2374
1933
  failureCode: __expectString(output.failureCode),
2375
1934
  failureReason: __expectString(output.failureReason),
2376
1935
  layerDigest: __expectString(output.layerDigest),
2377
1936
  };
2378
1937
  };
2379
- var deserializeAws_json1_1LayerFailureList = function (output, context) {
2380
- var retVal = (output || [])
2381
- .filter(function (e) { return e != null; })
2382
- .map(function (entry) {
1938
+ const deserializeAws_json1_1LayerFailureList = (output, context) => {
1939
+ const retVal = (output || [])
1940
+ .filter((e) => e != null)
1941
+ .map((entry) => {
2383
1942
  if (entry === null) {
2384
1943
  return null;
2385
1944
  }
@@ -2387,10 +1946,10 @@ var deserializeAws_json1_1LayerFailureList = function (output, context) {
2387
1946
  });
2388
1947
  return retVal;
2389
1948
  };
2390
- var deserializeAws_json1_1LayerList = function (output, context) {
2391
- var retVal = (output || [])
2392
- .filter(function (e) { return e != null; })
2393
- .map(function (entry) {
1949
+ const deserializeAws_json1_1LayerList = (output, context) => {
1950
+ const retVal = (output || [])
1951
+ .filter((e) => e != null)
1952
+ .map((entry) => {
2394
1953
  if (entry === null) {
2395
1954
  return null;
2396
1955
  }
@@ -2398,30 +1957,30 @@ var deserializeAws_json1_1LayerList = function (output, context) {
2398
1957
  });
2399
1958
  return retVal;
2400
1959
  };
2401
- var deserializeAws_json1_1LayerPartTooSmallException = function (output, context) {
1960
+ const deserializeAws_json1_1LayerPartTooSmallException = (output, context) => {
2402
1961
  return {
2403
1962
  message: __expectString(output.message),
2404
1963
  };
2405
1964
  };
2406
- var deserializeAws_json1_1LayersNotFoundException = function (output, context) {
1965
+ const deserializeAws_json1_1LayersNotFoundException = (output, context) => {
2407
1966
  return {
2408
1967
  message: __expectString(output.message),
2409
1968
  };
2410
1969
  };
2411
- var deserializeAws_json1_1LimitExceededException = function (output, context) {
1970
+ const deserializeAws_json1_1LimitExceededException = (output, context) => {
2412
1971
  return {
2413
1972
  message: __expectString(output.message),
2414
1973
  };
2415
1974
  };
2416
- var deserializeAws_json1_1ListTagsForResourceResponse = function (output, context) {
1975
+ const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
2417
1976
  return {
2418
1977
  tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
2419
1978
  };
2420
1979
  };
2421
- var deserializeAws_json1_1OperatingSystemList = function (output, context) {
2422
- var retVal = (output || [])
2423
- .filter(function (e) { return e != null; })
2424
- .map(function (entry) {
1980
+ const deserializeAws_json1_1OperatingSystemList = (output, context) => {
1981
+ const retVal = (output || [])
1982
+ .filter((e) => e != null)
1983
+ .map((entry) => {
2425
1984
  if (entry === null) {
2426
1985
  return null;
2427
1986
  }
@@ -2429,24 +1988,24 @@ var deserializeAws_json1_1OperatingSystemList = function (output, context) {
2429
1988
  });
2430
1989
  return retVal;
2431
1990
  };
2432
- var deserializeAws_json1_1PutImageResponse = function (output, context) {
1991
+ const deserializeAws_json1_1PutImageResponse = (output, context) => {
2433
1992
  return {
2434
1993
  image: output.image != null ? deserializeAws_json1_1Image(output.image, context) : undefined,
2435
1994
  };
2436
1995
  };
2437
- var deserializeAws_json1_1PutRegistryCatalogDataResponse = function (output, context) {
1996
+ const deserializeAws_json1_1PutRegistryCatalogDataResponse = (output, context) => {
2438
1997
  return {
2439
1998
  registryCatalogData: output.registryCatalogData != null
2440
1999
  ? deserializeAws_json1_1RegistryCatalogData(output.registryCatalogData, context)
2441
2000
  : undefined,
2442
2001
  };
2443
2002
  };
2444
- var deserializeAws_json1_1PutRepositoryCatalogDataResponse = function (output, context) {
2003
+ const deserializeAws_json1_1PutRepositoryCatalogDataResponse = (output, context) => {
2445
2004
  return {
2446
2005
  catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
2447
2006
  };
2448
2007
  };
2449
- var deserializeAws_json1_1ReferencedImageDetail = function (output, context) {
2008
+ const deserializeAws_json1_1ReferencedImageDetail = (output, context) => {
2450
2009
  return {
2451
2010
  artifactMediaType: __expectString(output.artifactMediaType),
2452
2011
  imageDigest: __expectString(output.imageDigest),
@@ -2457,12 +2016,12 @@ var deserializeAws_json1_1ReferencedImageDetail = function (output, context) {
2457
2016
  imageSizeInBytes: __expectLong(output.imageSizeInBytes),
2458
2017
  };
2459
2018
  };
2460
- var deserializeAws_json1_1ReferencedImagesNotFoundException = function (output, context) {
2019
+ const deserializeAws_json1_1ReferencedImagesNotFoundException = (output, context) => {
2461
2020
  return {
2462
2021
  message: __expectString(output.message),
2463
2022
  };
2464
2023
  };
2465
- var deserializeAws_json1_1Registry = function (output, context) {
2024
+ const deserializeAws_json1_1Registry = (output, context) => {
2466
2025
  return {
2467
2026
  aliases: output.aliases != null ? deserializeAws_json1_1RegistryAliasList(output.aliases, context) : undefined,
2468
2027
  registryArn: __expectString(output.registryArn),
@@ -2471,7 +2030,7 @@ var deserializeAws_json1_1Registry = function (output, context) {
2471
2030
  verified: __expectBoolean(output.verified),
2472
2031
  };
2473
2032
  };
2474
- var deserializeAws_json1_1RegistryAlias = function (output, context) {
2033
+ const deserializeAws_json1_1RegistryAlias = (output, context) => {
2475
2034
  return {
2476
2035
  defaultRegistryAlias: __expectBoolean(output.defaultRegistryAlias),
2477
2036
  name: __expectString(output.name),
@@ -2479,10 +2038,10 @@ var deserializeAws_json1_1RegistryAlias = function (output, context) {
2479
2038
  status: __expectString(output.status),
2480
2039
  };
2481
2040
  };
2482
- var deserializeAws_json1_1RegistryAliasList = function (output, context) {
2483
- var retVal = (output || [])
2484
- .filter(function (e) { return e != null; })
2485
- .map(function (entry) {
2041
+ const deserializeAws_json1_1RegistryAliasList = (output, context) => {
2042
+ const retVal = (output || [])
2043
+ .filter((e) => e != null)
2044
+ .map((entry) => {
2486
2045
  if (entry === null) {
2487
2046
  return null;
2488
2047
  }
@@ -2490,15 +2049,15 @@ var deserializeAws_json1_1RegistryAliasList = function (output, context) {
2490
2049
  });
2491
2050
  return retVal;
2492
2051
  };
2493
- var deserializeAws_json1_1RegistryCatalogData = function (output, context) {
2052
+ const deserializeAws_json1_1RegistryCatalogData = (output, context) => {
2494
2053
  return {
2495
2054
  displayName: __expectString(output.displayName),
2496
2055
  };
2497
2056
  };
2498
- var deserializeAws_json1_1RegistryList = function (output, context) {
2499
- var retVal = (output || [])
2500
- .filter(function (e) { return e != null; })
2501
- .map(function (entry) {
2057
+ const deserializeAws_json1_1RegistryList = (output, context) => {
2058
+ const retVal = (output || [])
2059
+ .filter((e) => e != null)
2060
+ .map((entry) => {
2502
2061
  if (entry === null) {
2503
2062
  return null;
2504
2063
  }
@@ -2506,12 +2065,12 @@ var deserializeAws_json1_1RegistryList = function (output, context) {
2506
2065
  });
2507
2066
  return retVal;
2508
2067
  };
2509
- var deserializeAws_json1_1RegistryNotFoundException = function (output, context) {
2068
+ const deserializeAws_json1_1RegistryNotFoundException = (output, context) => {
2510
2069
  return {
2511
2070
  message: __expectString(output.message),
2512
2071
  };
2513
2072
  };
2514
- var deserializeAws_json1_1Repository = function (output, context) {
2073
+ const deserializeAws_json1_1Repository = (output, context) => {
2515
2074
  return {
2516
2075
  createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
2517
2076
  registryId: __expectString(output.registryId),
@@ -2520,12 +2079,12 @@ var deserializeAws_json1_1Repository = function (output, context) {
2520
2079
  repositoryUri: __expectString(output.repositoryUri),
2521
2080
  };
2522
2081
  };
2523
- var deserializeAws_json1_1RepositoryAlreadyExistsException = function (output, context) {
2082
+ const deserializeAws_json1_1RepositoryAlreadyExistsException = (output, context) => {
2524
2083
  return {
2525
2084
  message: __expectString(output.message),
2526
2085
  };
2527
2086
  };
2528
- var deserializeAws_json1_1RepositoryCatalogData = function (output, context) {
2087
+ const deserializeAws_json1_1RepositoryCatalogData = (output, context) => {
2529
2088
  return {
2530
2089
  aboutText: __expectString(output.aboutText),
2531
2090
  architectures: output.architectures != null ? deserializeAws_json1_1ArchitectureList(output.architectures, context) : undefined,
@@ -2538,10 +2097,10 @@ var deserializeAws_json1_1RepositoryCatalogData = function (output, context) {
2538
2097
  usageText: __expectString(output.usageText),
2539
2098
  };
2540
2099
  };
2541
- var deserializeAws_json1_1RepositoryList = function (output, context) {
2542
- var retVal = (output || [])
2543
- .filter(function (e) { return e != null; })
2544
- .map(function (entry) {
2100
+ const deserializeAws_json1_1RepositoryList = (output, context) => {
2101
+ const retVal = (output || [])
2102
+ .filter((e) => e != null)
2103
+ .map((entry) => {
2545
2104
  if (entry === null) {
2546
2105
  return null;
2547
2106
  }
@@ -2549,43 +2108,43 @@ var deserializeAws_json1_1RepositoryList = function (output, context) {
2549
2108
  });
2550
2109
  return retVal;
2551
2110
  };
2552
- var deserializeAws_json1_1RepositoryNotEmptyException = function (output, context) {
2111
+ const deserializeAws_json1_1RepositoryNotEmptyException = (output, context) => {
2553
2112
  return {
2554
2113
  message: __expectString(output.message),
2555
2114
  };
2556
2115
  };
2557
- var deserializeAws_json1_1RepositoryNotFoundException = function (output, context) {
2116
+ const deserializeAws_json1_1RepositoryNotFoundException = (output, context) => {
2558
2117
  return {
2559
2118
  message: __expectString(output.message),
2560
2119
  };
2561
2120
  };
2562
- var deserializeAws_json1_1RepositoryPolicyNotFoundException = function (output, context) {
2121
+ const deserializeAws_json1_1RepositoryPolicyNotFoundException = (output, context) => {
2563
2122
  return {
2564
2123
  message: __expectString(output.message),
2565
2124
  };
2566
2125
  };
2567
- var deserializeAws_json1_1ServerException = function (output, context) {
2126
+ const deserializeAws_json1_1ServerException = (output, context) => {
2568
2127
  return {
2569
2128
  message: __expectString(output.message),
2570
2129
  };
2571
2130
  };
2572
- var deserializeAws_json1_1SetRepositoryPolicyResponse = function (output, context) {
2131
+ const deserializeAws_json1_1SetRepositoryPolicyResponse = (output, context) => {
2573
2132
  return {
2574
2133
  policyText: __expectString(output.policyText),
2575
2134
  registryId: __expectString(output.registryId),
2576
2135
  repositoryName: __expectString(output.repositoryName),
2577
2136
  };
2578
2137
  };
2579
- var deserializeAws_json1_1Tag = function (output, context) {
2138
+ const deserializeAws_json1_1Tag = (output, context) => {
2580
2139
  return {
2581
2140
  Key: __expectString(output.Key),
2582
2141
  Value: __expectString(output.Value),
2583
2142
  };
2584
2143
  };
2585
- var deserializeAws_json1_1TagList = function (output, context) {
2586
- var retVal = (output || [])
2587
- .filter(function (e) { return e != null; })
2588
- .map(function (entry) {
2144
+ const deserializeAws_json1_1TagList = (output, context) => {
2145
+ const retVal = (output || [])
2146
+ .filter((e) => e != null)
2147
+ .map((entry) => {
2589
2148
  if (entry === null) {
2590
2149
  return null;
2591
2150
  }
@@ -2593,23 +2152,23 @@ var deserializeAws_json1_1TagList = function (output, context) {
2593
2152
  });
2594
2153
  return retVal;
2595
2154
  };
2596
- var deserializeAws_json1_1TagResourceResponse = function (output, context) {
2155
+ const deserializeAws_json1_1TagResourceResponse = (output, context) => {
2597
2156
  return {};
2598
2157
  };
2599
- var deserializeAws_json1_1TooManyTagsException = function (output, context) {
2158
+ const deserializeAws_json1_1TooManyTagsException = (output, context) => {
2600
2159
  return {
2601
2160
  message: __expectString(output.message),
2602
2161
  };
2603
2162
  };
2604
- var deserializeAws_json1_1UnsupportedCommandException = function (output, context) {
2163
+ const deserializeAws_json1_1UnsupportedCommandException = (output, context) => {
2605
2164
  return {
2606
2165
  message: __expectString(output.message),
2607
2166
  };
2608
2167
  };
2609
- var deserializeAws_json1_1UntagResourceResponse = function (output, context) {
2168
+ const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
2610
2169
  return {};
2611
2170
  };
2612
- var deserializeAws_json1_1UploadLayerPartResponse = function (output, context) {
2171
+ const deserializeAws_json1_1UploadLayerPartResponse = (output, context) => {
2613
2172
  return {
2614
2173
  lastByteReceived: __expectLong(output.lastByteReceived),
2615
2174
  registryId: __expectString(output.registryId),
@@ -2617,80 +2176,57 @@ var deserializeAws_json1_1UploadLayerPartResponse = function (output, context) {
2617
2176
  uploadId: __expectString(output.uploadId),
2618
2177
  };
2619
2178
  };
2620
- var deserializeAws_json1_1UploadNotFoundException = function (output, context) {
2179
+ const deserializeAws_json1_1UploadNotFoundException = (output, context) => {
2621
2180
  return {
2622
2181
  message: __expectString(output.message),
2623
2182
  };
2624
2183
  };
2625
- var deserializeMetadata = function (output) {
2626
- var _a, _b;
2627
- return ({
2628
- httpStatusCode: output.statusCode,
2629
- requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
2630
- extendedRequestId: output.headers["x-amz-id-2"],
2631
- cfId: output.headers["x-amz-cf-id"],
2632
- });
2633
- };
2634
- var collectBody = function (streamBody, context) {
2635
- if (streamBody === void 0) { streamBody = new Uint8Array(); }
2184
+ const deserializeMetadata = (output) => ({
2185
+ httpStatusCode: output.statusCode,
2186
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
2187
+ extendedRequestId: output.headers["x-amz-id-2"],
2188
+ cfId: output.headers["x-amz-cf-id"],
2189
+ });
2190
+ const collectBody = (streamBody = new Uint8Array(), context) => {
2636
2191
  if (streamBody instanceof Uint8Array) {
2637
2192
  return Promise.resolve(streamBody);
2638
2193
  }
2639
2194
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
2640
2195
  };
2641
- var collectBodyString = function (streamBody, context) {
2642
- return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
2643
- };
2644
- var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
2645
- var _a, hostname, _b, protocol, port, basePath, contents;
2646
- return __generator(this, function (_c) {
2647
- switch (_c.label) {
2648
- case 0: return [4, context.endpoint()];
2649
- case 1:
2650
- _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
2651
- contents = {
2652
- protocol: protocol,
2653
- hostname: hostname,
2654
- port: port,
2655
- method: "POST",
2656
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
2657
- headers: headers,
2658
- };
2659
- if (resolvedHostname !== undefined) {
2660
- contents.hostname = resolvedHostname;
2661
- }
2662
- if (body !== undefined) {
2663
- contents.body = body;
2664
- }
2665
- return [2, new __HttpRequest(contents)];
2666
- }
2667
- });
2668
- }); };
2669
- var parseBody = function (streamBody, context) {
2670
- return collectBodyString(streamBody, context).then(function (encoded) {
2671
- if (encoded.length) {
2672
- return JSON.parse(encoded);
2673
- }
2674
- return {};
2675
- });
2196
+ const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
2197
+ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
2198
+ const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2199
+ const contents = {
2200
+ protocol,
2201
+ hostname,
2202
+ port,
2203
+ method: "POST",
2204
+ path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
2205
+ headers,
2206
+ };
2207
+ if (resolvedHostname !== undefined) {
2208
+ contents.hostname = resolvedHostname;
2209
+ }
2210
+ if (body !== undefined) {
2211
+ contents.body = body;
2212
+ }
2213
+ return new __HttpRequest(contents);
2676
2214
  };
2677
- var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
2678
- var value;
2679
- var _a;
2680
- return __generator(this, function (_b) {
2681
- switch (_b.label) {
2682
- case 0: return [4, parseBody(errorBody, context)];
2683
- case 1:
2684
- value = _b.sent();
2685
- value.message = (_a = value.message) !== null && _a !== void 0 ? _a : value.Message;
2686
- return [2, value];
2687
- }
2688
- });
2689
- }); };
2690
- var loadRestJsonErrorCode = function (output, data) {
2691
- var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
2692
- var sanitizeErrorCode = function (rawValue) {
2693
- var cleanValue = rawValue;
2215
+ const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
2216
+ if (encoded.length) {
2217
+ return JSON.parse(encoded);
2218
+ }
2219
+ return {};
2220
+ });
2221
+ const parseErrorBody = async (errorBody, context) => {
2222
+ const value = await parseBody(errorBody, context);
2223
+ value.message = value.message ?? value.Message;
2224
+ return value;
2225
+ };
2226
+ const loadRestJsonErrorCode = (output, data) => {
2227
+ const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
2228
+ const sanitizeErrorCode = (rawValue) => {
2229
+ let cleanValue = rawValue;
2694
2230
  if (typeof cleanValue === "number") {
2695
2231
  cleanValue = cleanValue.toString();
2696
2232
  }
@@ -2705,7 +2241,7 @@ var loadRestJsonErrorCode = function (output, data) {
2705
2241
  }
2706
2242
  return cleanValue;
2707
2243
  };
2708
- var headerKey = findKey(output.headers, "x-amzn-errortype");
2244
+ const headerKey = findKey(output.headers, "x-amzn-errortype");
2709
2245
  if (headerKey !== undefined) {
2710
2246
  return sanitizeErrorCode(output.headers[headerKey]);
2711
2247
  }