@aws-sdk/client-greengrass 3.52.0 → 3.53.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +11 -0
- package/dist-cjs/index.js +3 -0
- package/dist-cjs/models/GreengrassServiceException.js +11 -0
- package/dist-cjs/models/models_0.js +36 -5
- package/dist-cjs/protocols/Aws_restJson1.js +516 -1542
- package/dist-es/index.js +1 -0
- package/dist-es/models/GreengrassServiceException.js +12 -0
- package/dist-es/models/models_0.js +30 -1
- package/dist-es/protocols/Aws_restJson1.js +1315 -1857
- package/dist-types/index.d.ts +1 -0
- package/dist-types/models/GreengrassServiceException.d.ts +10 -0
- package/dist-types/models/models_0.d.ts +16 -7
- package/dist-types/ts3.4/index.d.ts +1 -0
- package/dist-types/ts3.4/models/GreengrassServiceException.d.ts +6 -0
- package/dist-types/ts3.4/models/models_0.d.ts +12 -7
- package/package.json +25 -25
|
@@ -6,6 +6,8 @@ exports.deserializeAws_restJson1ListConnectorDefinitionsCommand = exports.deseri
|
|
|
6
6
|
exports.deserializeAws_restJson1UpdateThingRuntimeConfigurationCommand = exports.deserializeAws_restJson1UpdateSubscriptionDefinitionCommand = exports.deserializeAws_restJson1UpdateResourceDefinitionCommand = exports.deserializeAws_restJson1UpdateLoggerDefinitionCommand = exports.deserializeAws_restJson1UpdateGroupCertificateConfigurationCommand = exports.deserializeAws_restJson1UpdateGroupCommand = exports.deserializeAws_restJson1UpdateFunctionDefinitionCommand = exports.deserializeAws_restJson1UpdateDeviceDefinitionCommand = exports.deserializeAws_restJson1UpdateCoreDefinitionCommand = exports.deserializeAws_restJson1UpdateConnectorDefinitionCommand = exports.deserializeAws_restJson1UpdateConnectivityInfoCommand = exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1StopBulkDeploymentCommand = exports.deserializeAws_restJson1StartBulkDeploymentCommand = exports.deserializeAws_restJson1ResetDeploymentsCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListSubscriptionDefinitionVersionsCommand = exports.deserializeAws_restJson1ListSubscriptionDefinitionsCommand = exports.deserializeAws_restJson1ListResourceDefinitionVersionsCommand = exports.deserializeAws_restJson1ListResourceDefinitionsCommand = exports.deserializeAws_restJson1ListLoggerDefinitionVersionsCommand = exports.deserializeAws_restJson1ListLoggerDefinitionsCommand = exports.deserializeAws_restJson1ListGroupVersionsCommand = exports.deserializeAws_restJson1ListGroupsCommand = exports.deserializeAws_restJson1ListGroupCertificateAuthoritiesCommand = exports.deserializeAws_restJson1ListFunctionDefinitionVersionsCommand = exports.deserializeAws_restJson1ListFunctionDefinitionsCommand = exports.deserializeAws_restJson1ListDeviceDefinitionVersionsCommand = exports.deserializeAws_restJson1ListDeviceDefinitionsCommand = exports.deserializeAws_restJson1ListDeploymentsCommand = exports.deserializeAws_restJson1ListCoreDefinitionVersionsCommand = exports.deserializeAws_restJson1ListCoreDefinitionsCommand = exports.deserializeAws_restJson1ListConnectorDefinitionVersionsCommand = void 0;
|
|
7
7
|
const protocol_http_1 = require("@aws-sdk/protocol-http");
|
|
8
8
|
const smithy_client_1 = require("@aws-sdk/smithy-client");
|
|
9
|
+
const GreengrassServiceException_1 = require("../models/GreengrassServiceException");
|
|
10
|
+
const models_0_1 = require("../models/models_0");
|
|
9
11
|
const serializeAws_restJson1AssociateRoleToGroupCommand = async (input, context) => {
|
|
10
12
|
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
|
|
11
13
|
const headers = {
|
|
@@ -2783,35 +2785,19 @@ const deserializeAws_restJson1AssociateRoleToGroupCommandError = async (output,
|
|
|
2783
2785
|
switch (errorCode) {
|
|
2784
2786
|
case "BadRequestException":
|
|
2785
2787
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
2786
|
-
|
|
2787
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2788
|
-
name: errorCode,
|
|
2789
|
-
$metadata: deserializeMetadata(output),
|
|
2790
|
-
};
|
|
2791
|
-
break;
|
|
2788
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2792
2789
|
case "InternalServerErrorException":
|
|
2793
2790
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
2794
|
-
|
|
2795
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2796
|
-
name: errorCode,
|
|
2797
|
-
$metadata: deserializeMetadata(output),
|
|
2798
|
-
};
|
|
2799
|
-
break;
|
|
2791
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2800
2792
|
default:
|
|
2801
2793
|
const parsedBody = parsedOutput.body;
|
|
2802
|
-
|
|
2803
|
-
|
|
2804
|
-
...parsedBody,
|
|
2805
|
-
name: `${errorCode}`,
|
|
2806
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2794
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
2795
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2807
2796
|
$fault: "client",
|
|
2808
2797
|
$metadata: deserializeMetadata(output),
|
|
2809
|
-
};
|
|
2798
|
+
});
|
|
2799
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2810
2800
|
}
|
|
2811
|
-
const message = response.message || response.Message || errorCode;
|
|
2812
|
-
response.message = message;
|
|
2813
|
-
delete response.Message;
|
|
2814
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2815
2801
|
};
|
|
2816
2802
|
const deserializeAws_restJson1AssociateServiceRoleToAccountCommand = async (output, context) => {
|
|
2817
2803
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2839,35 +2825,19 @@ const deserializeAws_restJson1AssociateServiceRoleToAccountCommandError = async
|
|
|
2839
2825
|
switch (errorCode) {
|
|
2840
2826
|
case "BadRequestException":
|
|
2841
2827
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
2842
|
-
|
|
2843
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2844
|
-
name: errorCode,
|
|
2845
|
-
$metadata: deserializeMetadata(output),
|
|
2846
|
-
};
|
|
2847
|
-
break;
|
|
2828
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2848
2829
|
case "InternalServerErrorException":
|
|
2849
2830
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
2850
|
-
|
|
2851
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
2852
|
-
name: errorCode,
|
|
2853
|
-
$metadata: deserializeMetadata(output),
|
|
2854
|
-
};
|
|
2855
|
-
break;
|
|
2831
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
2856
2832
|
default:
|
|
2857
2833
|
const parsedBody = parsedOutput.body;
|
|
2858
|
-
|
|
2859
|
-
|
|
2860
|
-
...parsedBody,
|
|
2861
|
-
name: `${errorCode}`,
|
|
2862
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2834
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
2835
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2863
2836
|
$fault: "client",
|
|
2864
2837
|
$metadata: deserializeMetadata(output),
|
|
2865
|
-
};
|
|
2838
|
+
});
|
|
2839
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2866
2840
|
}
|
|
2867
|
-
const message = response.message || response.Message || errorCode;
|
|
2868
|
-
response.message = message;
|
|
2869
|
-
delete response.Message;
|
|
2870
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2871
2841
|
};
|
|
2872
2842
|
const deserializeAws_restJson1CreateConnectorDefinitionCommand = async (output, context) => {
|
|
2873
2843
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2919,27 +2889,16 @@ const deserializeAws_restJson1CreateConnectorDefinitionCommandError = async (out
|
|
|
2919
2889
|
switch (errorCode) {
|
|
2920
2890
|
case "BadRequestException":
|
|
2921
2891
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
2922
|
-
|
|
2923
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2924
|
-
name: errorCode,
|
|
2925
|
-
$metadata: deserializeMetadata(output),
|
|
2926
|
-
};
|
|
2927
|
-
break;
|
|
2892
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2928
2893
|
default:
|
|
2929
2894
|
const parsedBody = parsedOutput.body;
|
|
2930
|
-
|
|
2931
|
-
|
|
2932
|
-
...parsedBody,
|
|
2933
|
-
name: `${errorCode}`,
|
|
2934
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2895
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
2896
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2935
2897
|
$fault: "client",
|
|
2936
2898
|
$metadata: deserializeMetadata(output),
|
|
2937
|
-
};
|
|
2899
|
+
});
|
|
2900
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2938
2901
|
}
|
|
2939
|
-
const message = response.message || response.Message || errorCode;
|
|
2940
|
-
response.message = message;
|
|
2941
|
-
delete response.Message;
|
|
2942
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2943
2902
|
};
|
|
2944
2903
|
const deserializeAws_restJson1CreateConnectorDefinitionVersionCommand = async (output, context) => {
|
|
2945
2904
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -2979,27 +2938,16 @@ const deserializeAws_restJson1CreateConnectorDefinitionVersionCommandError = asy
|
|
|
2979
2938
|
switch (errorCode) {
|
|
2980
2939
|
case "BadRequestException":
|
|
2981
2940
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
2982
|
-
|
|
2983
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
2984
|
-
name: errorCode,
|
|
2985
|
-
$metadata: deserializeMetadata(output),
|
|
2986
|
-
};
|
|
2987
|
-
break;
|
|
2941
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
2988
2942
|
default:
|
|
2989
2943
|
const parsedBody = parsedOutput.body;
|
|
2990
|
-
|
|
2991
|
-
|
|
2992
|
-
...parsedBody,
|
|
2993
|
-
name: `${errorCode}`,
|
|
2994
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2944
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
2945
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2995
2946
|
$fault: "client",
|
|
2996
2947
|
$metadata: deserializeMetadata(output),
|
|
2997
|
-
};
|
|
2948
|
+
});
|
|
2949
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2998
2950
|
}
|
|
2999
|
-
const message = response.message || response.Message || errorCode;
|
|
3000
|
-
response.message = message;
|
|
3001
|
-
delete response.Message;
|
|
3002
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3003
2951
|
};
|
|
3004
2952
|
const deserializeAws_restJson1CreateCoreDefinitionCommand = async (output, context) => {
|
|
3005
2953
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3051,27 +2999,16 @@ const deserializeAws_restJson1CreateCoreDefinitionCommandError = async (output,
|
|
|
3051
2999
|
switch (errorCode) {
|
|
3052
3000
|
case "BadRequestException":
|
|
3053
3001
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3054
|
-
|
|
3055
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3056
|
-
name: errorCode,
|
|
3057
|
-
$metadata: deserializeMetadata(output),
|
|
3058
|
-
};
|
|
3059
|
-
break;
|
|
3002
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3060
3003
|
default:
|
|
3061
3004
|
const parsedBody = parsedOutput.body;
|
|
3062
|
-
|
|
3063
|
-
|
|
3064
|
-
...parsedBody,
|
|
3065
|
-
name: `${errorCode}`,
|
|
3066
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3005
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3006
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3067
3007
|
$fault: "client",
|
|
3068
3008
|
$metadata: deserializeMetadata(output),
|
|
3069
|
-
};
|
|
3009
|
+
});
|
|
3010
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3070
3011
|
}
|
|
3071
|
-
const message = response.message || response.Message || errorCode;
|
|
3072
|
-
response.message = message;
|
|
3073
|
-
delete response.Message;
|
|
3074
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3075
3012
|
};
|
|
3076
3013
|
const deserializeAws_restJson1CreateCoreDefinitionVersionCommand = async (output, context) => {
|
|
3077
3014
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3111,27 +3048,16 @@ const deserializeAws_restJson1CreateCoreDefinitionVersionCommandError = async (o
|
|
|
3111
3048
|
switch (errorCode) {
|
|
3112
3049
|
case "BadRequestException":
|
|
3113
3050
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3114
|
-
|
|
3115
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3116
|
-
name: errorCode,
|
|
3117
|
-
$metadata: deserializeMetadata(output),
|
|
3118
|
-
};
|
|
3119
|
-
break;
|
|
3051
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3120
3052
|
default:
|
|
3121
3053
|
const parsedBody = parsedOutput.body;
|
|
3122
|
-
|
|
3123
|
-
|
|
3124
|
-
...parsedBody,
|
|
3125
|
-
name: `${errorCode}`,
|
|
3126
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3054
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3055
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3127
3056
|
$fault: "client",
|
|
3128
3057
|
$metadata: deserializeMetadata(output),
|
|
3129
|
-
};
|
|
3058
|
+
});
|
|
3059
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3130
3060
|
}
|
|
3131
|
-
const message = response.message || response.Message || errorCode;
|
|
3132
|
-
response.message = message;
|
|
3133
|
-
delete response.Message;
|
|
3134
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3135
3061
|
};
|
|
3136
3062
|
const deserializeAws_restJson1CreateDeploymentCommand = async (output, context) => {
|
|
3137
3063
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3163,27 +3089,16 @@ const deserializeAws_restJson1CreateDeploymentCommandError = async (output, cont
|
|
|
3163
3089
|
switch (errorCode) {
|
|
3164
3090
|
case "BadRequestException":
|
|
3165
3091
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3166
|
-
|
|
3167
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3168
|
-
name: errorCode,
|
|
3169
|
-
$metadata: deserializeMetadata(output),
|
|
3170
|
-
};
|
|
3171
|
-
break;
|
|
3092
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3172
3093
|
default:
|
|
3173
3094
|
const parsedBody = parsedOutput.body;
|
|
3174
|
-
|
|
3175
|
-
|
|
3176
|
-
...parsedBody,
|
|
3177
|
-
name: `${errorCode}`,
|
|
3178
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3095
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3096
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3179
3097
|
$fault: "client",
|
|
3180
3098
|
$metadata: deserializeMetadata(output),
|
|
3181
|
-
};
|
|
3099
|
+
});
|
|
3100
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3182
3101
|
}
|
|
3183
|
-
const message = response.message || response.Message || errorCode;
|
|
3184
|
-
response.message = message;
|
|
3185
|
-
delete response.Message;
|
|
3186
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3187
3102
|
};
|
|
3188
3103
|
const deserializeAws_restJson1CreateDeviceDefinitionCommand = async (output, context) => {
|
|
3189
3104
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3235,27 +3150,16 @@ const deserializeAws_restJson1CreateDeviceDefinitionCommandError = async (output
|
|
|
3235
3150
|
switch (errorCode) {
|
|
3236
3151
|
case "BadRequestException":
|
|
3237
3152
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3238
|
-
|
|
3239
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3240
|
-
name: errorCode,
|
|
3241
|
-
$metadata: deserializeMetadata(output),
|
|
3242
|
-
};
|
|
3243
|
-
break;
|
|
3153
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3244
3154
|
default:
|
|
3245
3155
|
const parsedBody = parsedOutput.body;
|
|
3246
|
-
|
|
3247
|
-
|
|
3248
|
-
...parsedBody,
|
|
3249
|
-
name: `${errorCode}`,
|
|
3250
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3156
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3157
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3251
3158
|
$fault: "client",
|
|
3252
3159
|
$metadata: deserializeMetadata(output),
|
|
3253
|
-
};
|
|
3160
|
+
});
|
|
3161
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3254
3162
|
}
|
|
3255
|
-
const message = response.message || response.Message || errorCode;
|
|
3256
|
-
response.message = message;
|
|
3257
|
-
delete response.Message;
|
|
3258
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3259
3163
|
};
|
|
3260
3164
|
const deserializeAws_restJson1CreateDeviceDefinitionVersionCommand = async (output, context) => {
|
|
3261
3165
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3295,27 +3199,16 @@ const deserializeAws_restJson1CreateDeviceDefinitionVersionCommandError = async
|
|
|
3295
3199
|
switch (errorCode) {
|
|
3296
3200
|
case "BadRequestException":
|
|
3297
3201
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3298
|
-
|
|
3299
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3300
|
-
name: errorCode,
|
|
3301
|
-
$metadata: deserializeMetadata(output),
|
|
3302
|
-
};
|
|
3303
|
-
break;
|
|
3202
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3304
3203
|
default:
|
|
3305
3204
|
const parsedBody = parsedOutput.body;
|
|
3306
|
-
|
|
3307
|
-
|
|
3308
|
-
...parsedBody,
|
|
3309
|
-
name: `${errorCode}`,
|
|
3310
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3205
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3206
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3311
3207
|
$fault: "client",
|
|
3312
3208
|
$metadata: deserializeMetadata(output),
|
|
3313
|
-
};
|
|
3209
|
+
});
|
|
3210
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3314
3211
|
}
|
|
3315
|
-
const message = response.message || response.Message || errorCode;
|
|
3316
|
-
response.message = message;
|
|
3317
|
-
delete response.Message;
|
|
3318
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3319
3212
|
};
|
|
3320
3213
|
const deserializeAws_restJson1CreateFunctionDefinitionCommand = async (output, context) => {
|
|
3321
3214
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3367,27 +3260,16 @@ const deserializeAws_restJson1CreateFunctionDefinitionCommandError = async (outp
|
|
|
3367
3260
|
switch (errorCode) {
|
|
3368
3261
|
case "BadRequestException":
|
|
3369
3262
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3370
|
-
|
|
3371
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3372
|
-
name: errorCode,
|
|
3373
|
-
$metadata: deserializeMetadata(output),
|
|
3374
|
-
};
|
|
3375
|
-
break;
|
|
3263
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3376
3264
|
default:
|
|
3377
3265
|
const parsedBody = parsedOutput.body;
|
|
3378
|
-
|
|
3379
|
-
|
|
3380
|
-
...parsedBody,
|
|
3381
|
-
name: `${errorCode}`,
|
|
3382
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3266
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3267
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3383
3268
|
$fault: "client",
|
|
3384
3269
|
$metadata: deserializeMetadata(output),
|
|
3385
|
-
};
|
|
3270
|
+
});
|
|
3271
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3386
3272
|
}
|
|
3387
|
-
const message = response.message || response.Message || errorCode;
|
|
3388
|
-
response.message = message;
|
|
3389
|
-
delete response.Message;
|
|
3390
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3391
3273
|
};
|
|
3392
3274
|
const deserializeAws_restJson1CreateFunctionDefinitionVersionCommand = async (output, context) => {
|
|
3393
3275
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3427,27 +3309,16 @@ const deserializeAws_restJson1CreateFunctionDefinitionVersionCommandError = asyn
|
|
|
3427
3309
|
switch (errorCode) {
|
|
3428
3310
|
case "BadRequestException":
|
|
3429
3311
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3430
|
-
|
|
3431
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3432
|
-
name: errorCode,
|
|
3433
|
-
$metadata: deserializeMetadata(output),
|
|
3434
|
-
};
|
|
3435
|
-
break;
|
|
3312
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3436
3313
|
default:
|
|
3437
3314
|
const parsedBody = parsedOutput.body;
|
|
3438
|
-
|
|
3439
|
-
|
|
3440
|
-
...parsedBody,
|
|
3441
|
-
name: `${errorCode}`,
|
|
3442
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3315
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3316
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3443
3317
|
$fault: "client",
|
|
3444
3318
|
$metadata: deserializeMetadata(output),
|
|
3445
|
-
};
|
|
3319
|
+
});
|
|
3320
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3446
3321
|
}
|
|
3447
|
-
const message = response.message || response.Message || errorCode;
|
|
3448
|
-
response.message = message;
|
|
3449
|
-
delete response.Message;
|
|
3450
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3451
3322
|
};
|
|
3452
3323
|
const deserializeAws_restJson1CreateGroupCommand = async (output, context) => {
|
|
3453
3324
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3499,27 +3370,16 @@ const deserializeAws_restJson1CreateGroupCommandError = async (output, context)
|
|
|
3499
3370
|
switch (errorCode) {
|
|
3500
3371
|
case "BadRequestException":
|
|
3501
3372
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3502
|
-
|
|
3503
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3504
|
-
name: errorCode,
|
|
3505
|
-
$metadata: deserializeMetadata(output),
|
|
3506
|
-
};
|
|
3507
|
-
break;
|
|
3373
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3508
3374
|
default:
|
|
3509
3375
|
const parsedBody = parsedOutput.body;
|
|
3510
|
-
|
|
3511
|
-
|
|
3512
|
-
...parsedBody,
|
|
3513
|
-
name: `${errorCode}`,
|
|
3514
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3376
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3377
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3515
3378
|
$fault: "client",
|
|
3516
3379
|
$metadata: deserializeMetadata(output),
|
|
3517
|
-
};
|
|
3380
|
+
});
|
|
3381
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3518
3382
|
}
|
|
3519
|
-
const message = response.message || response.Message || errorCode;
|
|
3520
|
-
response.message = message;
|
|
3521
|
-
delete response.Message;
|
|
3522
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3523
3383
|
};
|
|
3524
3384
|
const deserializeAws_restJson1CreateGroupCertificateAuthorityCommand = async (output, context) => {
|
|
3525
3385
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3547,35 +3407,19 @@ const deserializeAws_restJson1CreateGroupCertificateAuthorityCommandError = asyn
|
|
|
3547
3407
|
switch (errorCode) {
|
|
3548
3408
|
case "BadRequestException":
|
|
3549
3409
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3550
|
-
|
|
3551
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3552
|
-
name: errorCode,
|
|
3553
|
-
$metadata: deserializeMetadata(output),
|
|
3554
|
-
};
|
|
3555
|
-
break;
|
|
3410
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3556
3411
|
case "InternalServerErrorException":
|
|
3557
3412
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
3558
|
-
|
|
3559
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3560
|
-
name: errorCode,
|
|
3561
|
-
$metadata: deserializeMetadata(output),
|
|
3562
|
-
};
|
|
3563
|
-
break;
|
|
3413
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3564
3414
|
default:
|
|
3565
3415
|
const parsedBody = parsedOutput.body;
|
|
3566
|
-
|
|
3567
|
-
|
|
3568
|
-
...parsedBody,
|
|
3569
|
-
name: `${errorCode}`,
|
|
3570
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3416
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3417
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3571
3418
|
$fault: "client",
|
|
3572
3419
|
$metadata: deserializeMetadata(output),
|
|
3573
|
-
};
|
|
3420
|
+
});
|
|
3421
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3574
3422
|
}
|
|
3575
|
-
const message = response.message || response.Message || errorCode;
|
|
3576
|
-
response.message = message;
|
|
3577
|
-
delete response.Message;
|
|
3578
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3579
3423
|
};
|
|
3580
3424
|
const deserializeAws_restJson1CreateGroupVersionCommand = async (output, context) => {
|
|
3581
3425
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3615,27 +3459,16 @@ const deserializeAws_restJson1CreateGroupVersionCommandError = async (output, co
|
|
|
3615
3459
|
switch (errorCode) {
|
|
3616
3460
|
case "BadRequestException":
|
|
3617
3461
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3618
|
-
|
|
3619
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3620
|
-
name: errorCode,
|
|
3621
|
-
$metadata: deserializeMetadata(output),
|
|
3622
|
-
};
|
|
3623
|
-
break;
|
|
3462
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3624
3463
|
default:
|
|
3625
3464
|
const parsedBody = parsedOutput.body;
|
|
3626
|
-
|
|
3627
|
-
|
|
3628
|
-
...parsedBody,
|
|
3629
|
-
name: `${errorCode}`,
|
|
3630
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3465
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3466
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3631
3467
|
$fault: "client",
|
|
3632
3468
|
$metadata: deserializeMetadata(output),
|
|
3633
|
-
};
|
|
3469
|
+
});
|
|
3470
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3634
3471
|
}
|
|
3635
|
-
const message = response.message || response.Message || errorCode;
|
|
3636
|
-
response.message = message;
|
|
3637
|
-
delete response.Message;
|
|
3638
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3639
3472
|
};
|
|
3640
3473
|
const deserializeAws_restJson1CreateLoggerDefinitionCommand = async (output, context) => {
|
|
3641
3474
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3687,27 +3520,16 @@ const deserializeAws_restJson1CreateLoggerDefinitionCommandError = async (output
|
|
|
3687
3520
|
switch (errorCode) {
|
|
3688
3521
|
case "BadRequestException":
|
|
3689
3522
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3690
|
-
|
|
3691
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3692
|
-
name: errorCode,
|
|
3693
|
-
$metadata: deserializeMetadata(output),
|
|
3694
|
-
};
|
|
3695
|
-
break;
|
|
3523
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3696
3524
|
default:
|
|
3697
3525
|
const parsedBody = parsedOutput.body;
|
|
3698
|
-
|
|
3699
|
-
|
|
3700
|
-
...parsedBody,
|
|
3701
|
-
name: `${errorCode}`,
|
|
3702
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3526
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3527
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3703
3528
|
$fault: "client",
|
|
3704
3529
|
$metadata: deserializeMetadata(output),
|
|
3705
|
-
};
|
|
3530
|
+
});
|
|
3531
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3706
3532
|
}
|
|
3707
|
-
const message = response.message || response.Message || errorCode;
|
|
3708
|
-
response.message = message;
|
|
3709
|
-
delete response.Message;
|
|
3710
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3711
3533
|
};
|
|
3712
3534
|
const deserializeAws_restJson1CreateLoggerDefinitionVersionCommand = async (output, context) => {
|
|
3713
3535
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3747,27 +3569,16 @@ const deserializeAws_restJson1CreateLoggerDefinitionVersionCommandError = async
|
|
|
3747
3569
|
switch (errorCode) {
|
|
3748
3570
|
case "BadRequestException":
|
|
3749
3571
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3750
|
-
|
|
3751
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3752
|
-
name: errorCode,
|
|
3753
|
-
$metadata: deserializeMetadata(output),
|
|
3754
|
-
};
|
|
3755
|
-
break;
|
|
3572
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3756
3573
|
default:
|
|
3757
3574
|
const parsedBody = parsedOutput.body;
|
|
3758
|
-
|
|
3759
|
-
|
|
3760
|
-
...parsedBody,
|
|
3761
|
-
name: `${errorCode}`,
|
|
3762
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3575
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3576
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3763
3577
|
$fault: "client",
|
|
3764
3578
|
$metadata: deserializeMetadata(output),
|
|
3765
|
-
};
|
|
3579
|
+
});
|
|
3580
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3766
3581
|
}
|
|
3767
|
-
const message = response.message || response.Message || errorCode;
|
|
3768
|
-
response.message = message;
|
|
3769
|
-
delete response.Message;
|
|
3770
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3771
3582
|
};
|
|
3772
3583
|
const deserializeAws_restJson1CreateResourceDefinitionCommand = async (output, context) => {
|
|
3773
3584
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3819,27 +3630,16 @@ const deserializeAws_restJson1CreateResourceDefinitionCommandError = async (outp
|
|
|
3819
3630
|
switch (errorCode) {
|
|
3820
3631
|
case "BadRequestException":
|
|
3821
3632
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3822
|
-
|
|
3823
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3824
|
-
name: errorCode,
|
|
3825
|
-
$metadata: deserializeMetadata(output),
|
|
3826
|
-
};
|
|
3827
|
-
break;
|
|
3633
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3828
3634
|
default:
|
|
3829
3635
|
const parsedBody = parsedOutput.body;
|
|
3830
|
-
|
|
3831
|
-
|
|
3832
|
-
...parsedBody,
|
|
3833
|
-
name: `${errorCode}`,
|
|
3834
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3636
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3637
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3835
3638
|
$fault: "client",
|
|
3836
3639
|
$metadata: deserializeMetadata(output),
|
|
3837
|
-
};
|
|
3640
|
+
});
|
|
3641
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3838
3642
|
}
|
|
3839
|
-
const message = response.message || response.Message || errorCode;
|
|
3840
|
-
response.message = message;
|
|
3841
|
-
delete response.Message;
|
|
3842
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3843
3643
|
};
|
|
3844
3644
|
const deserializeAws_restJson1CreateResourceDefinitionVersionCommand = async (output, context) => {
|
|
3845
3645
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3879,27 +3679,16 @@ const deserializeAws_restJson1CreateResourceDefinitionVersionCommandError = asyn
|
|
|
3879
3679
|
switch (errorCode) {
|
|
3880
3680
|
case "BadRequestException":
|
|
3881
3681
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3882
|
-
|
|
3883
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3884
|
-
name: errorCode,
|
|
3885
|
-
$metadata: deserializeMetadata(output),
|
|
3886
|
-
};
|
|
3887
|
-
break;
|
|
3682
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3888
3683
|
default:
|
|
3889
3684
|
const parsedBody = parsedOutput.body;
|
|
3890
|
-
|
|
3891
|
-
|
|
3892
|
-
...parsedBody,
|
|
3893
|
-
name: `${errorCode}`,
|
|
3894
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3685
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3686
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3895
3687
|
$fault: "client",
|
|
3896
3688
|
$metadata: deserializeMetadata(output),
|
|
3897
|
-
};
|
|
3689
|
+
});
|
|
3690
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3898
3691
|
}
|
|
3899
|
-
const message = response.message || response.Message || errorCode;
|
|
3900
|
-
response.message = message;
|
|
3901
|
-
delete response.Message;
|
|
3902
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3903
3692
|
};
|
|
3904
3693
|
const deserializeAws_restJson1CreateSoftwareUpdateJobCommand = async (output, context) => {
|
|
3905
3694
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3935,35 +3724,19 @@ const deserializeAws_restJson1CreateSoftwareUpdateJobCommandError = async (outpu
|
|
|
3935
3724
|
switch (errorCode) {
|
|
3936
3725
|
case "BadRequestException":
|
|
3937
3726
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
3938
|
-
|
|
3939
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
3940
|
-
name: errorCode,
|
|
3941
|
-
$metadata: deserializeMetadata(output),
|
|
3942
|
-
};
|
|
3943
|
-
break;
|
|
3727
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
3944
3728
|
case "InternalServerErrorException":
|
|
3945
3729
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
3946
|
-
|
|
3947
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
3948
|
-
name: errorCode,
|
|
3949
|
-
$metadata: deserializeMetadata(output),
|
|
3950
|
-
};
|
|
3951
|
-
break;
|
|
3730
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
3952
3731
|
default:
|
|
3953
3732
|
const parsedBody = parsedOutput.body;
|
|
3954
|
-
|
|
3955
|
-
|
|
3956
|
-
...parsedBody,
|
|
3957
|
-
name: `${errorCode}`,
|
|
3958
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3733
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3734
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3959
3735
|
$fault: "client",
|
|
3960
3736
|
$metadata: deserializeMetadata(output),
|
|
3961
|
-
};
|
|
3737
|
+
});
|
|
3738
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3962
3739
|
}
|
|
3963
|
-
const message = response.message || response.Message || errorCode;
|
|
3964
|
-
response.message = message;
|
|
3965
|
-
delete response.Message;
|
|
3966
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3967
3740
|
};
|
|
3968
3741
|
const deserializeAws_restJson1CreateSubscriptionDefinitionCommand = async (output, context) => {
|
|
3969
3742
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4015,27 +3788,16 @@ const deserializeAws_restJson1CreateSubscriptionDefinitionCommandError = async (
|
|
|
4015
3788
|
switch (errorCode) {
|
|
4016
3789
|
case "BadRequestException":
|
|
4017
3790
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4018
|
-
|
|
4019
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4020
|
-
name: errorCode,
|
|
4021
|
-
$metadata: deserializeMetadata(output),
|
|
4022
|
-
};
|
|
4023
|
-
break;
|
|
3791
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4024
3792
|
default:
|
|
4025
3793
|
const parsedBody = parsedOutput.body;
|
|
4026
|
-
|
|
4027
|
-
|
|
4028
|
-
...parsedBody,
|
|
4029
|
-
name: `${errorCode}`,
|
|
4030
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3794
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3795
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4031
3796
|
$fault: "client",
|
|
4032
3797
|
$metadata: deserializeMetadata(output),
|
|
4033
|
-
};
|
|
3798
|
+
});
|
|
3799
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4034
3800
|
}
|
|
4035
|
-
const message = response.message || response.Message || errorCode;
|
|
4036
|
-
response.message = message;
|
|
4037
|
-
delete response.Message;
|
|
4038
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4039
3801
|
};
|
|
4040
3802
|
const deserializeAws_restJson1CreateSubscriptionDefinitionVersionCommand = async (output, context) => {
|
|
4041
3803
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4075,27 +3837,16 @@ const deserializeAws_restJson1CreateSubscriptionDefinitionVersionCommandError =
|
|
|
4075
3837
|
switch (errorCode) {
|
|
4076
3838
|
case "BadRequestException":
|
|
4077
3839
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4078
|
-
|
|
4079
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4080
|
-
name: errorCode,
|
|
4081
|
-
$metadata: deserializeMetadata(output),
|
|
4082
|
-
};
|
|
4083
|
-
break;
|
|
3840
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4084
3841
|
default:
|
|
4085
3842
|
const parsedBody = parsedOutput.body;
|
|
4086
|
-
|
|
4087
|
-
|
|
4088
|
-
...parsedBody,
|
|
4089
|
-
name: `${errorCode}`,
|
|
4090
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3843
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3844
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4091
3845
|
$fault: "client",
|
|
4092
3846
|
$metadata: deserializeMetadata(output),
|
|
4093
|
-
};
|
|
3847
|
+
});
|
|
3848
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4094
3849
|
}
|
|
4095
|
-
const message = response.message || response.Message || errorCode;
|
|
4096
|
-
response.message = message;
|
|
4097
|
-
delete response.Message;
|
|
4098
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4099
3850
|
};
|
|
4100
3851
|
const deserializeAws_restJson1DeleteConnectorDefinitionCommand = async (output, context) => {
|
|
4101
3852
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4119,27 +3870,16 @@ const deserializeAws_restJson1DeleteConnectorDefinitionCommandError = async (out
|
|
|
4119
3870
|
switch (errorCode) {
|
|
4120
3871
|
case "BadRequestException":
|
|
4121
3872
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4122
|
-
|
|
4123
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4124
|
-
name: errorCode,
|
|
4125
|
-
$metadata: deserializeMetadata(output),
|
|
4126
|
-
};
|
|
4127
|
-
break;
|
|
3873
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4128
3874
|
default:
|
|
4129
3875
|
const parsedBody = parsedOutput.body;
|
|
4130
|
-
|
|
4131
|
-
|
|
4132
|
-
...parsedBody,
|
|
4133
|
-
name: `${errorCode}`,
|
|
4134
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3876
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3877
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4135
3878
|
$fault: "client",
|
|
4136
3879
|
$metadata: deserializeMetadata(output),
|
|
4137
|
-
};
|
|
3880
|
+
});
|
|
3881
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4138
3882
|
}
|
|
4139
|
-
const message = response.message || response.Message || errorCode;
|
|
4140
|
-
response.message = message;
|
|
4141
|
-
delete response.Message;
|
|
4142
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4143
3883
|
};
|
|
4144
3884
|
const deserializeAws_restJson1DeleteCoreDefinitionCommand = async (output, context) => {
|
|
4145
3885
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4163,27 +3903,16 @@ const deserializeAws_restJson1DeleteCoreDefinitionCommandError = async (output,
|
|
|
4163
3903
|
switch (errorCode) {
|
|
4164
3904
|
case "BadRequestException":
|
|
4165
3905
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4166
|
-
|
|
4167
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4168
|
-
name: errorCode,
|
|
4169
|
-
$metadata: deserializeMetadata(output),
|
|
4170
|
-
};
|
|
4171
|
-
break;
|
|
3906
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4172
3907
|
default:
|
|
4173
3908
|
const parsedBody = parsedOutput.body;
|
|
4174
|
-
|
|
4175
|
-
|
|
4176
|
-
...parsedBody,
|
|
4177
|
-
name: `${errorCode}`,
|
|
4178
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3909
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3910
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4179
3911
|
$fault: "client",
|
|
4180
3912
|
$metadata: deserializeMetadata(output),
|
|
4181
|
-
};
|
|
3913
|
+
});
|
|
3914
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4182
3915
|
}
|
|
4183
|
-
const message = response.message || response.Message || errorCode;
|
|
4184
|
-
response.message = message;
|
|
4185
|
-
delete response.Message;
|
|
4186
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4187
3916
|
};
|
|
4188
3917
|
const deserializeAws_restJson1DeleteDeviceDefinitionCommand = async (output, context) => {
|
|
4189
3918
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4207,27 +3936,16 @@ const deserializeAws_restJson1DeleteDeviceDefinitionCommandError = async (output
|
|
|
4207
3936
|
switch (errorCode) {
|
|
4208
3937
|
case "BadRequestException":
|
|
4209
3938
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4210
|
-
|
|
4211
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4212
|
-
name: errorCode,
|
|
4213
|
-
$metadata: deserializeMetadata(output),
|
|
4214
|
-
};
|
|
4215
|
-
break;
|
|
3939
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4216
3940
|
default:
|
|
4217
3941
|
const parsedBody = parsedOutput.body;
|
|
4218
|
-
|
|
4219
|
-
|
|
4220
|
-
...parsedBody,
|
|
4221
|
-
name: `${errorCode}`,
|
|
4222
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3942
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3943
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4223
3944
|
$fault: "client",
|
|
4224
3945
|
$metadata: deserializeMetadata(output),
|
|
4225
|
-
};
|
|
3946
|
+
});
|
|
3947
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4226
3948
|
}
|
|
4227
|
-
const message = response.message || response.Message || errorCode;
|
|
4228
|
-
response.message = message;
|
|
4229
|
-
delete response.Message;
|
|
4230
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4231
3949
|
};
|
|
4232
3950
|
const deserializeAws_restJson1DeleteFunctionDefinitionCommand = async (output, context) => {
|
|
4233
3951
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4251,27 +3969,16 @@ const deserializeAws_restJson1DeleteFunctionDefinitionCommandError = async (outp
|
|
|
4251
3969
|
switch (errorCode) {
|
|
4252
3970
|
case "BadRequestException":
|
|
4253
3971
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4254
|
-
|
|
4255
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4256
|
-
name: errorCode,
|
|
4257
|
-
$metadata: deserializeMetadata(output),
|
|
4258
|
-
};
|
|
4259
|
-
break;
|
|
3972
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4260
3973
|
default:
|
|
4261
3974
|
const parsedBody = parsedOutput.body;
|
|
4262
|
-
|
|
4263
|
-
|
|
4264
|
-
...parsedBody,
|
|
4265
|
-
name: `${errorCode}`,
|
|
4266
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3975
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
3976
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4267
3977
|
$fault: "client",
|
|
4268
3978
|
$metadata: deserializeMetadata(output),
|
|
4269
|
-
};
|
|
3979
|
+
});
|
|
3980
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4270
3981
|
}
|
|
4271
|
-
const message = response.message || response.Message || errorCode;
|
|
4272
|
-
response.message = message;
|
|
4273
|
-
delete response.Message;
|
|
4274
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4275
3982
|
};
|
|
4276
3983
|
const deserializeAws_restJson1DeleteGroupCommand = async (output, context) => {
|
|
4277
3984
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4295,27 +4002,16 @@ const deserializeAws_restJson1DeleteGroupCommandError = async (output, context)
|
|
|
4295
4002
|
switch (errorCode) {
|
|
4296
4003
|
case "BadRequestException":
|
|
4297
4004
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4298
|
-
|
|
4299
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4300
|
-
name: errorCode,
|
|
4301
|
-
$metadata: deserializeMetadata(output),
|
|
4302
|
-
};
|
|
4303
|
-
break;
|
|
4005
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4304
4006
|
default:
|
|
4305
4007
|
const parsedBody = parsedOutput.body;
|
|
4306
|
-
|
|
4307
|
-
|
|
4308
|
-
...parsedBody,
|
|
4309
|
-
name: `${errorCode}`,
|
|
4310
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4008
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4009
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4311
4010
|
$fault: "client",
|
|
4312
4011
|
$metadata: deserializeMetadata(output),
|
|
4313
|
-
};
|
|
4012
|
+
});
|
|
4013
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4314
4014
|
}
|
|
4315
|
-
const message = response.message || response.Message || errorCode;
|
|
4316
|
-
response.message = message;
|
|
4317
|
-
delete response.Message;
|
|
4318
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4319
4015
|
};
|
|
4320
4016
|
const deserializeAws_restJson1DeleteLoggerDefinitionCommand = async (output, context) => {
|
|
4321
4017
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4339,27 +4035,16 @@ const deserializeAws_restJson1DeleteLoggerDefinitionCommandError = async (output
|
|
|
4339
4035
|
switch (errorCode) {
|
|
4340
4036
|
case "BadRequestException":
|
|
4341
4037
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4342
|
-
|
|
4343
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4344
|
-
name: errorCode,
|
|
4345
|
-
$metadata: deserializeMetadata(output),
|
|
4346
|
-
};
|
|
4347
|
-
break;
|
|
4038
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4348
4039
|
default:
|
|
4349
4040
|
const parsedBody = parsedOutput.body;
|
|
4350
|
-
|
|
4351
|
-
|
|
4352
|
-
...parsedBody,
|
|
4353
|
-
name: `${errorCode}`,
|
|
4354
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4041
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4042
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4355
4043
|
$fault: "client",
|
|
4356
4044
|
$metadata: deserializeMetadata(output),
|
|
4357
|
-
};
|
|
4045
|
+
});
|
|
4046
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4358
4047
|
}
|
|
4359
|
-
const message = response.message || response.Message || errorCode;
|
|
4360
|
-
response.message = message;
|
|
4361
|
-
delete response.Message;
|
|
4362
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4363
4048
|
};
|
|
4364
4049
|
const deserializeAws_restJson1DeleteResourceDefinitionCommand = async (output, context) => {
|
|
4365
4050
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4383,27 +4068,16 @@ const deserializeAws_restJson1DeleteResourceDefinitionCommandError = async (outp
|
|
|
4383
4068
|
switch (errorCode) {
|
|
4384
4069
|
case "BadRequestException":
|
|
4385
4070
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4386
|
-
|
|
4387
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4388
|
-
name: errorCode,
|
|
4389
|
-
$metadata: deserializeMetadata(output),
|
|
4390
|
-
};
|
|
4391
|
-
break;
|
|
4071
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4392
4072
|
default:
|
|
4393
4073
|
const parsedBody = parsedOutput.body;
|
|
4394
|
-
|
|
4395
|
-
|
|
4396
|
-
...parsedBody,
|
|
4397
|
-
name: `${errorCode}`,
|
|
4398
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4074
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4075
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4399
4076
|
$fault: "client",
|
|
4400
4077
|
$metadata: deserializeMetadata(output),
|
|
4401
|
-
};
|
|
4078
|
+
});
|
|
4079
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4402
4080
|
}
|
|
4403
|
-
const message = response.message || response.Message || errorCode;
|
|
4404
|
-
response.message = message;
|
|
4405
|
-
delete response.Message;
|
|
4406
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4407
4081
|
};
|
|
4408
4082
|
const deserializeAws_restJson1DeleteSubscriptionDefinitionCommand = async (output, context) => {
|
|
4409
4083
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4427,27 +4101,16 @@ const deserializeAws_restJson1DeleteSubscriptionDefinitionCommandError = async (
|
|
|
4427
4101
|
switch (errorCode) {
|
|
4428
4102
|
case "BadRequestException":
|
|
4429
4103
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4430
|
-
|
|
4431
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4432
|
-
name: errorCode,
|
|
4433
|
-
$metadata: deserializeMetadata(output),
|
|
4434
|
-
};
|
|
4435
|
-
break;
|
|
4104
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4436
4105
|
default:
|
|
4437
4106
|
const parsedBody = parsedOutput.body;
|
|
4438
|
-
|
|
4439
|
-
|
|
4440
|
-
...parsedBody,
|
|
4441
|
-
name: `${errorCode}`,
|
|
4442
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4107
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4108
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4443
4109
|
$fault: "client",
|
|
4444
4110
|
$metadata: deserializeMetadata(output),
|
|
4445
|
-
};
|
|
4111
|
+
});
|
|
4112
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4446
4113
|
}
|
|
4447
|
-
const message = response.message || response.Message || errorCode;
|
|
4448
|
-
response.message = message;
|
|
4449
|
-
delete response.Message;
|
|
4450
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4451
4114
|
};
|
|
4452
4115
|
const deserializeAws_restJson1DisassociateRoleFromGroupCommand = async (output, context) => {
|
|
4453
4116
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4475,35 +4138,19 @@ const deserializeAws_restJson1DisassociateRoleFromGroupCommandError = async (out
|
|
|
4475
4138
|
switch (errorCode) {
|
|
4476
4139
|
case "BadRequestException":
|
|
4477
4140
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4478
|
-
|
|
4479
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4480
|
-
name: errorCode,
|
|
4481
|
-
$metadata: deserializeMetadata(output),
|
|
4482
|
-
};
|
|
4483
|
-
break;
|
|
4141
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4484
4142
|
case "InternalServerErrorException":
|
|
4485
4143
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
4486
|
-
|
|
4487
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4488
|
-
name: errorCode,
|
|
4489
|
-
$metadata: deserializeMetadata(output),
|
|
4490
|
-
};
|
|
4491
|
-
break;
|
|
4144
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4492
4145
|
default:
|
|
4493
4146
|
const parsedBody = parsedOutput.body;
|
|
4494
|
-
|
|
4495
|
-
|
|
4496
|
-
...parsedBody,
|
|
4497
|
-
name: `${errorCode}`,
|
|
4498
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4147
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4148
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4499
4149
|
$fault: "client",
|
|
4500
4150
|
$metadata: deserializeMetadata(output),
|
|
4501
|
-
};
|
|
4151
|
+
});
|
|
4152
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4502
4153
|
}
|
|
4503
|
-
const message = response.message || response.Message || errorCode;
|
|
4504
|
-
response.message = message;
|
|
4505
|
-
delete response.Message;
|
|
4506
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4507
4154
|
};
|
|
4508
4155
|
const deserializeAws_restJson1DisassociateServiceRoleFromAccountCommand = async (output, context) => {
|
|
4509
4156
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4531,27 +4178,16 @@ const deserializeAws_restJson1DisassociateServiceRoleFromAccountCommandError = a
|
|
|
4531
4178
|
switch (errorCode) {
|
|
4532
4179
|
case "InternalServerErrorException":
|
|
4533
4180
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
4534
|
-
|
|
4535
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4536
|
-
name: errorCode,
|
|
4537
|
-
$metadata: deserializeMetadata(output),
|
|
4538
|
-
};
|
|
4539
|
-
break;
|
|
4181
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4540
4182
|
default:
|
|
4541
4183
|
const parsedBody = parsedOutput.body;
|
|
4542
|
-
|
|
4543
|
-
|
|
4544
|
-
...parsedBody,
|
|
4545
|
-
name: `${errorCode}`,
|
|
4546
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4184
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4185
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4547
4186
|
$fault: "client",
|
|
4548
4187
|
$metadata: deserializeMetadata(output),
|
|
4549
|
-
};
|
|
4188
|
+
});
|
|
4189
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4550
4190
|
}
|
|
4551
|
-
const message = response.message || response.Message || errorCode;
|
|
4552
|
-
response.message = message;
|
|
4553
|
-
delete response.Message;
|
|
4554
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4555
4191
|
};
|
|
4556
4192
|
const deserializeAws_restJson1GetAssociatedRoleCommand = async (output, context) => {
|
|
4557
4193
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4583,35 +4219,19 @@ const deserializeAws_restJson1GetAssociatedRoleCommandError = async (output, con
|
|
|
4583
4219
|
switch (errorCode) {
|
|
4584
4220
|
case "BadRequestException":
|
|
4585
4221
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4586
|
-
|
|
4587
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4588
|
-
name: errorCode,
|
|
4589
|
-
$metadata: deserializeMetadata(output),
|
|
4590
|
-
};
|
|
4591
|
-
break;
|
|
4222
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4592
4223
|
case "InternalServerErrorException":
|
|
4593
4224
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
4594
|
-
|
|
4595
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4596
|
-
name: errorCode,
|
|
4597
|
-
$metadata: deserializeMetadata(output),
|
|
4598
|
-
};
|
|
4599
|
-
break;
|
|
4225
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4600
4226
|
default:
|
|
4601
4227
|
const parsedBody = parsedOutput.body;
|
|
4602
|
-
|
|
4603
|
-
|
|
4604
|
-
...parsedBody,
|
|
4605
|
-
name: `${errorCode}`,
|
|
4606
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4228
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4229
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4607
4230
|
$fault: "client",
|
|
4608
4231
|
$metadata: deserializeMetadata(output),
|
|
4609
|
-
};
|
|
4232
|
+
});
|
|
4233
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4610
4234
|
}
|
|
4611
|
-
const message = response.message || response.Message || errorCode;
|
|
4612
|
-
response.message = message;
|
|
4613
|
-
delete response.Message;
|
|
4614
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4615
4235
|
};
|
|
4616
4236
|
const deserializeAws_restJson1GetBulkDeploymentStatusCommand = async (output, context) => {
|
|
4617
4237
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4659,27 +4279,16 @@ const deserializeAws_restJson1GetBulkDeploymentStatusCommandError = async (outpu
|
|
|
4659
4279
|
switch (errorCode) {
|
|
4660
4280
|
case "BadRequestException":
|
|
4661
4281
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4662
|
-
|
|
4663
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4664
|
-
name: errorCode,
|
|
4665
|
-
$metadata: deserializeMetadata(output),
|
|
4666
|
-
};
|
|
4667
|
-
break;
|
|
4282
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4668
4283
|
default:
|
|
4669
4284
|
const parsedBody = parsedOutput.body;
|
|
4670
|
-
|
|
4671
|
-
|
|
4672
|
-
...parsedBody,
|
|
4673
|
-
name: `${errorCode}`,
|
|
4674
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4285
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4286
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4675
4287
|
$fault: "client",
|
|
4676
4288
|
$metadata: deserializeMetadata(output),
|
|
4677
|
-
};
|
|
4289
|
+
});
|
|
4290
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4678
4291
|
}
|
|
4679
|
-
const message = response.message || response.Message || errorCode;
|
|
4680
|
-
response.message = message;
|
|
4681
|
-
delete response.Message;
|
|
4682
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4683
4292
|
};
|
|
4684
4293
|
const deserializeAws_restJson1GetConnectivityInfoCommand = async (output, context) => {
|
|
4685
4294
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4711,35 +4320,19 @@ const deserializeAws_restJson1GetConnectivityInfoCommandError = async (output, c
|
|
|
4711
4320
|
switch (errorCode) {
|
|
4712
4321
|
case "BadRequestException":
|
|
4713
4322
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4714
|
-
|
|
4715
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4716
|
-
name: errorCode,
|
|
4717
|
-
$metadata: deserializeMetadata(output),
|
|
4718
|
-
};
|
|
4719
|
-
break;
|
|
4323
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4720
4324
|
case "InternalServerErrorException":
|
|
4721
4325
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
4722
|
-
|
|
4723
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
4724
|
-
name: errorCode,
|
|
4725
|
-
$metadata: deserializeMetadata(output),
|
|
4726
|
-
};
|
|
4727
|
-
break;
|
|
4326
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
4728
4327
|
default:
|
|
4729
4328
|
const parsedBody = parsedOutput.body;
|
|
4730
|
-
|
|
4731
|
-
|
|
4732
|
-
...parsedBody,
|
|
4733
|
-
name: `${errorCode}`,
|
|
4734
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4329
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4330
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4735
4331
|
$fault: "client",
|
|
4736
4332
|
$metadata: deserializeMetadata(output),
|
|
4737
|
-
};
|
|
4333
|
+
});
|
|
4334
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4738
4335
|
}
|
|
4739
|
-
const message = response.message || response.Message || errorCode;
|
|
4740
|
-
response.message = message;
|
|
4741
|
-
delete response.Message;
|
|
4742
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4743
4336
|
};
|
|
4744
4337
|
const deserializeAws_restJson1GetConnectorDefinitionCommand = async (output, context) => {
|
|
4745
4338
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4795,27 +4388,16 @@ const deserializeAws_restJson1GetConnectorDefinitionCommandError = async (output
|
|
|
4795
4388
|
switch (errorCode) {
|
|
4796
4389
|
case "BadRequestException":
|
|
4797
4390
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4798
|
-
|
|
4799
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4800
|
-
name: errorCode,
|
|
4801
|
-
$metadata: deserializeMetadata(output),
|
|
4802
|
-
};
|
|
4803
|
-
break;
|
|
4391
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4804
4392
|
default:
|
|
4805
4393
|
const parsedBody = parsedOutput.body;
|
|
4806
|
-
|
|
4807
|
-
|
|
4808
|
-
...parsedBody,
|
|
4809
|
-
name: `${errorCode}`,
|
|
4810
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4394
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4395
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4811
4396
|
$fault: "client",
|
|
4812
4397
|
$metadata: deserializeMetadata(output),
|
|
4813
|
-
};
|
|
4398
|
+
});
|
|
4399
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4814
4400
|
}
|
|
4815
|
-
const message = response.message || response.Message || errorCode;
|
|
4816
|
-
response.message = message;
|
|
4817
|
-
delete response.Message;
|
|
4818
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4819
4401
|
};
|
|
4820
4402
|
const deserializeAws_restJson1GetConnectorDefinitionVersionCommand = async (output, context) => {
|
|
4821
4403
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4863,27 +4445,16 @@ const deserializeAws_restJson1GetConnectorDefinitionVersionCommandError = async
|
|
|
4863
4445
|
switch (errorCode) {
|
|
4864
4446
|
case "BadRequestException":
|
|
4865
4447
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4866
|
-
|
|
4867
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4868
|
-
name: errorCode,
|
|
4869
|
-
$metadata: deserializeMetadata(output),
|
|
4870
|
-
};
|
|
4871
|
-
break;
|
|
4448
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4872
4449
|
default:
|
|
4873
4450
|
const parsedBody = parsedOutput.body;
|
|
4874
|
-
|
|
4875
|
-
|
|
4876
|
-
...parsedBody,
|
|
4877
|
-
name: `${errorCode}`,
|
|
4878
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4451
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4452
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4879
4453
|
$fault: "client",
|
|
4880
4454
|
$metadata: deserializeMetadata(output),
|
|
4881
|
-
};
|
|
4455
|
+
});
|
|
4456
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4882
4457
|
}
|
|
4883
|
-
const message = response.message || response.Message || errorCode;
|
|
4884
|
-
response.message = message;
|
|
4885
|
-
delete response.Message;
|
|
4886
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4887
4458
|
};
|
|
4888
4459
|
const deserializeAws_restJson1GetCoreDefinitionCommand = async (output, context) => {
|
|
4889
4460
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -4939,27 +4510,16 @@ const deserializeAws_restJson1GetCoreDefinitionCommandError = async (output, con
|
|
|
4939
4510
|
switch (errorCode) {
|
|
4940
4511
|
case "BadRequestException":
|
|
4941
4512
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
4942
|
-
|
|
4943
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
4944
|
-
name: errorCode,
|
|
4945
|
-
$metadata: deserializeMetadata(output),
|
|
4946
|
-
};
|
|
4947
|
-
break;
|
|
4513
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
4948
4514
|
default:
|
|
4949
4515
|
const parsedBody = parsedOutput.body;
|
|
4950
|
-
|
|
4951
|
-
|
|
4952
|
-
...parsedBody,
|
|
4953
|
-
name: `${errorCode}`,
|
|
4954
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4516
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4517
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4955
4518
|
$fault: "client",
|
|
4956
4519
|
$metadata: deserializeMetadata(output),
|
|
4957
|
-
};
|
|
4520
|
+
});
|
|
4521
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4958
4522
|
}
|
|
4959
|
-
const message = response.message || response.Message || errorCode;
|
|
4960
|
-
response.message = message;
|
|
4961
|
-
delete response.Message;
|
|
4962
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4963
4523
|
};
|
|
4964
4524
|
const deserializeAws_restJson1GetCoreDefinitionVersionCommand = async (output, context) => {
|
|
4965
4525
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5007,27 +4567,16 @@ const deserializeAws_restJson1GetCoreDefinitionVersionCommandError = async (outp
|
|
|
5007
4567
|
switch (errorCode) {
|
|
5008
4568
|
case "BadRequestException":
|
|
5009
4569
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5010
|
-
|
|
5011
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5012
|
-
name: errorCode,
|
|
5013
|
-
$metadata: deserializeMetadata(output),
|
|
5014
|
-
};
|
|
5015
|
-
break;
|
|
4570
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5016
4571
|
default:
|
|
5017
4572
|
const parsedBody = parsedOutput.body;
|
|
5018
|
-
|
|
5019
|
-
|
|
5020
|
-
...parsedBody,
|
|
5021
|
-
name: `${errorCode}`,
|
|
5022
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4573
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4574
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5023
4575
|
$fault: "client",
|
|
5024
4576
|
$metadata: deserializeMetadata(output),
|
|
5025
|
-
};
|
|
4577
|
+
});
|
|
4578
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5026
4579
|
}
|
|
5027
|
-
const message = response.message || response.Message || errorCode;
|
|
5028
|
-
response.message = message;
|
|
5029
|
-
delete response.Message;
|
|
5030
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5031
4580
|
};
|
|
5032
4581
|
const deserializeAws_restJson1GetDeploymentStatusCommand = async (output, context) => {
|
|
5033
4582
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5071,27 +4620,16 @@ const deserializeAws_restJson1GetDeploymentStatusCommandError = async (output, c
|
|
|
5071
4620
|
switch (errorCode) {
|
|
5072
4621
|
case "BadRequestException":
|
|
5073
4622
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5074
|
-
|
|
5075
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5076
|
-
name: errorCode,
|
|
5077
|
-
$metadata: deserializeMetadata(output),
|
|
5078
|
-
};
|
|
5079
|
-
break;
|
|
4623
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5080
4624
|
default:
|
|
5081
4625
|
const parsedBody = parsedOutput.body;
|
|
5082
|
-
|
|
5083
|
-
|
|
5084
|
-
...parsedBody,
|
|
5085
|
-
name: `${errorCode}`,
|
|
5086
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4626
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4627
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5087
4628
|
$fault: "client",
|
|
5088
4629
|
$metadata: deserializeMetadata(output),
|
|
5089
|
-
};
|
|
4630
|
+
});
|
|
4631
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5090
4632
|
}
|
|
5091
|
-
const message = response.message || response.Message || errorCode;
|
|
5092
|
-
response.message = message;
|
|
5093
|
-
delete response.Message;
|
|
5094
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5095
4633
|
};
|
|
5096
4634
|
const deserializeAws_restJson1GetDeviceDefinitionCommand = async (output, context) => {
|
|
5097
4635
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5147,27 +4685,16 @@ const deserializeAws_restJson1GetDeviceDefinitionCommandError = async (output, c
|
|
|
5147
4685
|
switch (errorCode) {
|
|
5148
4686
|
case "BadRequestException":
|
|
5149
4687
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5150
|
-
|
|
5151
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5152
|
-
name: errorCode,
|
|
5153
|
-
$metadata: deserializeMetadata(output),
|
|
5154
|
-
};
|
|
5155
|
-
break;
|
|
4688
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5156
4689
|
default:
|
|
5157
4690
|
const parsedBody = parsedOutput.body;
|
|
5158
|
-
|
|
5159
|
-
|
|
5160
|
-
...parsedBody,
|
|
5161
|
-
name: `${errorCode}`,
|
|
5162
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4691
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4692
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5163
4693
|
$fault: "client",
|
|
5164
4694
|
$metadata: deserializeMetadata(output),
|
|
5165
|
-
};
|
|
4695
|
+
});
|
|
4696
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5166
4697
|
}
|
|
5167
|
-
const message = response.message || response.Message || errorCode;
|
|
5168
|
-
response.message = message;
|
|
5169
|
-
delete response.Message;
|
|
5170
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5171
4698
|
};
|
|
5172
4699
|
const deserializeAws_restJson1GetDeviceDefinitionVersionCommand = async (output, context) => {
|
|
5173
4700
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5215,27 +4742,16 @@ const deserializeAws_restJson1GetDeviceDefinitionVersionCommandError = async (ou
|
|
|
5215
4742
|
switch (errorCode) {
|
|
5216
4743
|
case "BadRequestException":
|
|
5217
4744
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5218
|
-
|
|
5219
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5220
|
-
name: errorCode,
|
|
5221
|
-
$metadata: deserializeMetadata(output),
|
|
5222
|
-
};
|
|
5223
|
-
break;
|
|
4745
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5224
4746
|
default:
|
|
5225
4747
|
const parsedBody = parsedOutput.body;
|
|
5226
|
-
|
|
5227
|
-
|
|
5228
|
-
...parsedBody,
|
|
5229
|
-
name: `${errorCode}`,
|
|
5230
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4748
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4749
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5231
4750
|
$fault: "client",
|
|
5232
4751
|
$metadata: deserializeMetadata(output),
|
|
5233
|
-
};
|
|
4752
|
+
});
|
|
4753
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5234
4754
|
}
|
|
5235
|
-
const message = response.message || response.Message || errorCode;
|
|
5236
|
-
response.message = message;
|
|
5237
|
-
delete response.Message;
|
|
5238
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5239
4755
|
};
|
|
5240
4756
|
const deserializeAws_restJson1GetFunctionDefinitionCommand = async (output, context) => {
|
|
5241
4757
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5291,27 +4807,16 @@ const deserializeAws_restJson1GetFunctionDefinitionCommandError = async (output,
|
|
|
5291
4807
|
switch (errorCode) {
|
|
5292
4808
|
case "BadRequestException":
|
|
5293
4809
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5294
|
-
|
|
5295
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5296
|
-
name: errorCode,
|
|
5297
|
-
$metadata: deserializeMetadata(output),
|
|
5298
|
-
};
|
|
5299
|
-
break;
|
|
4810
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5300
4811
|
default:
|
|
5301
4812
|
const parsedBody = parsedOutput.body;
|
|
5302
|
-
|
|
5303
|
-
|
|
5304
|
-
...parsedBody,
|
|
5305
|
-
name: `${errorCode}`,
|
|
5306
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4813
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4814
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5307
4815
|
$fault: "client",
|
|
5308
4816
|
$metadata: deserializeMetadata(output),
|
|
5309
|
-
};
|
|
4817
|
+
});
|
|
4818
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5310
4819
|
}
|
|
5311
|
-
const message = response.message || response.Message || errorCode;
|
|
5312
|
-
response.message = message;
|
|
5313
|
-
delete response.Message;
|
|
5314
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5315
4820
|
};
|
|
5316
4821
|
const deserializeAws_restJson1GetFunctionDefinitionVersionCommand = async (output, context) => {
|
|
5317
4822
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5359,27 +4864,16 @@ const deserializeAws_restJson1GetFunctionDefinitionVersionCommandError = async (
|
|
|
5359
4864
|
switch (errorCode) {
|
|
5360
4865
|
case "BadRequestException":
|
|
5361
4866
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5362
|
-
|
|
5363
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5364
|
-
name: errorCode,
|
|
5365
|
-
$metadata: deserializeMetadata(output),
|
|
5366
|
-
};
|
|
5367
|
-
break;
|
|
4867
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5368
4868
|
default:
|
|
5369
4869
|
const parsedBody = parsedOutput.body;
|
|
5370
|
-
|
|
5371
|
-
|
|
5372
|
-
...parsedBody,
|
|
5373
|
-
name: `${errorCode}`,
|
|
5374
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4870
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4871
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5375
4872
|
$fault: "client",
|
|
5376
4873
|
$metadata: deserializeMetadata(output),
|
|
5377
|
-
};
|
|
4874
|
+
});
|
|
4875
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5378
4876
|
}
|
|
5379
|
-
const message = response.message || response.Message || errorCode;
|
|
5380
|
-
response.message = message;
|
|
5381
|
-
delete response.Message;
|
|
5382
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5383
4877
|
};
|
|
5384
4878
|
const deserializeAws_restJson1GetGroupCommand = async (output, context) => {
|
|
5385
4879
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5435,27 +4929,16 @@ const deserializeAws_restJson1GetGroupCommandError = async (output, context) =>
|
|
|
5435
4929
|
switch (errorCode) {
|
|
5436
4930
|
case "BadRequestException":
|
|
5437
4931
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5438
|
-
|
|
5439
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5440
|
-
name: errorCode,
|
|
5441
|
-
$metadata: deserializeMetadata(output),
|
|
5442
|
-
};
|
|
5443
|
-
break;
|
|
4932
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5444
4933
|
default:
|
|
5445
4934
|
const parsedBody = parsedOutput.body;
|
|
5446
|
-
|
|
5447
|
-
|
|
5448
|
-
...parsedBody,
|
|
5449
|
-
name: `${errorCode}`,
|
|
5450
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4935
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4936
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5451
4937
|
$fault: "client",
|
|
5452
4938
|
$metadata: deserializeMetadata(output),
|
|
5453
|
-
};
|
|
4939
|
+
});
|
|
4940
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5454
4941
|
}
|
|
5455
|
-
const message = response.message || response.Message || errorCode;
|
|
5456
|
-
response.message = message;
|
|
5457
|
-
delete response.Message;
|
|
5458
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5459
4942
|
};
|
|
5460
4943
|
const deserializeAws_restJson1GetGroupCertificateAuthorityCommand = async (output, context) => {
|
|
5461
4944
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5491,35 +4974,19 @@ const deserializeAws_restJson1GetGroupCertificateAuthorityCommandError = async (
|
|
|
5491
4974
|
switch (errorCode) {
|
|
5492
4975
|
case "BadRequestException":
|
|
5493
4976
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5494
|
-
|
|
5495
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5496
|
-
name: errorCode,
|
|
5497
|
-
$metadata: deserializeMetadata(output),
|
|
5498
|
-
};
|
|
5499
|
-
break;
|
|
4977
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5500
4978
|
case "InternalServerErrorException":
|
|
5501
4979
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
5502
|
-
|
|
5503
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5504
|
-
name: errorCode,
|
|
5505
|
-
$metadata: deserializeMetadata(output),
|
|
5506
|
-
};
|
|
5507
|
-
break;
|
|
4980
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5508
4981
|
default:
|
|
5509
4982
|
const parsedBody = parsedOutput.body;
|
|
5510
|
-
|
|
5511
|
-
|
|
5512
|
-
...parsedBody,
|
|
5513
|
-
name: `${errorCode}`,
|
|
5514
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4983
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
4984
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5515
4985
|
$fault: "client",
|
|
5516
4986
|
$metadata: deserializeMetadata(output),
|
|
5517
|
-
};
|
|
4987
|
+
});
|
|
4988
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5518
4989
|
}
|
|
5519
|
-
const message = response.message || response.Message || errorCode;
|
|
5520
|
-
response.message = message;
|
|
5521
|
-
delete response.Message;
|
|
5522
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5523
4990
|
};
|
|
5524
4991
|
const deserializeAws_restJson1GetGroupCertificateConfigurationCommand = async (output, context) => {
|
|
5525
4992
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5556,35 +5023,19 @@ const deserializeAws_restJson1GetGroupCertificateConfigurationCommandError = asy
|
|
|
5556
5023
|
switch (errorCode) {
|
|
5557
5024
|
case "BadRequestException":
|
|
5558
5025
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5559
|
-
|
|
5560
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5561
|
-
name: errorCode,
|
|
5562
|
-
$metadata: deserializeMetadata(output),
|
|
5563
|
-
};
|
|
5564
|
-
break;
|
|
5026
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5565
5027
|
case "InternalServerErrorException":
|
|
5566
5028
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
5567
|
-
|
|
5568
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5569
|
-
name: errorCode,
|
|
5570
|
-
$metadata: deserializeMetadata(output),
|
|
5571
|
-
};
|
|
5572
|
-
break;
|
|
5029
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5573
5030
|
default:
|
|
5574
5031
|
const parsedBody = parsedOutput.body;
|
|
5575
|
-
|
|
5576
|
-
|
|
5577
|
-
...parsedBody,
|
|
5578
|
-
name: `${errorCode}`,
|
|
5579
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5032
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5033
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5580
5034
|
$fault: "client",
|
|
5581
5035
|
$metadata: deserializeMetadata(output),
|
|
5582
|
-
};
|
|
5036
|
+
});
|
|
5037
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5583
5038
|
}
|
|
5584
|
-
const message = response.message || response.Message || errorCode;
|
|
5585
|
-
response.message = message;
|
|
5586
|
-
delete response.Message;
|
|
5587
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5588
5039
|
};
|
|
5589
5040
|
const deserializeAws_restJson1GetGroupVersionCommand = async (output, context) => {
|
|
5590
5041
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5628,27 +5079,16 @@ const deserializeAws_restJson1GetGroupVersionCommandError = async (output, conte
|
|
|
5628
5079
|
switch (errorCode) {
|
|
5629
5080
|
case "BadRequestException":
|
|
5630
5081
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5631
|
-
|
|
5632
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5633
|
-
name: errorCode,
|
|
5634
|
-
$metadata: deserializeMetadata(output),
|
|
5635
|
-
};
|
|
5636
|
-
break;
|
|
5082
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5637
5083
|
default:
|
|
5638
5084
|
const parsedBody = parsedOutput.body;
|
|
5639
|
-
|
|
5640
|
-
|
|
5641
|
-
...parsedBody,
|
|
5642
|
-
name: `${errorCode}`,
|
|
5643
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5085
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5086
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5644
5087
|
$fault: "client",
|
|
5645
5088
|
$metadata: deserializeMetadata(output),
|
|
5646
|
-
};
|
|
5089
|
+
});
|
|
5090
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5647
5091
|
}
|
|
5648
|
-
const message = response.message || response.Message || errorCode;
|
|
5649
|
-
response.message = message;
|
|
5650
|
-
delete response.Message;
|
|
5651
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5652
5092
|
};
|
|
5653
5093
|
const deserializeAws_restJson1GetLoggerDefinitionCommand = async (output, context) => {
|
|
5654
5094
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5704,27 +5144,16 @@ const deserializeAws_restJson1GetLoggerDefinitionCommandError = async (output, c
|
|
|
5704
5144
|
switch (errorCode) {
|
|
5705
5145
|
case "BadRequestException":
|
|
5706
5146
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5707
|
-
|
|
5708
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5709
|
-
name: errorCode,
|
|
5710
|
-
$metadata: deserializeMetadata(output),
|
|
5711
|
-
};
|
|
5712
|
-
break;
|
|
5147
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5713
5148
|
default:
|
|
5714
5149
|
const parsedBody = parsedOutput.body;
|
|
5715
|
-
|
|
5716
|
-
|
|
5717
|
-
...parsedBody,
|
|
5718
|
-
name: `${errorCode}`,
|
|
5719
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5150
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5151
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5720
5152
|
$fault: "client",
|
|
5721
5153
|
$metadata: deserializeMetadata(output),
|
|
5722
|
-
};
|
|
5154
|
+
});
|
|
5155
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5723
5156
|
}
|
|
5724
|
-
const message = response.message || response.Message || errorCode;
|
|
5725
|
-
response.message = message;
|
|
5726
|
-
delete response.Message;
|
|
5727
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5728
5157
|
};
|
|
5729
5158
|
const deserializeAws_restJson1GetLoggerDefinitionVersionCommand = async (output, context) => {
|
|
5730
5159
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5768,27 +5197,16 @@ const deserializeAws_restJson1GetLoggerDefinitionVersionCommandError = async (ou
|
|
|
5768
5197
|
switch (errorCode) {
|
|
5769
5198
|
case "BadRequestException":
|
|
5770
5199
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5771
|
-
|
|
5772
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5773
|
-
name: errorCode,
|
|
5774
|
-
$metadata: deserializeMetadata(output),
|
|
5775
|
-
};
|
|
5776
|
-
break;
|
|
5200
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5777
5201
|
default:
|
|
5778
5202
|
const parsedBody = parsedOutput.body;
|
|
5779
|
-
|
|
5780
|
-
|
|
5781
|
-
...parsedBody,
|
|
5782
|
-
name: `${errorCode}`,
|
|
5783
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5203
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5204
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5784
5205
|
$fault: "client",
|
|
5785
5206
|
$metadata: deserializeMetadata(output),
|
|
5786
|
-
};
|
|
5207
|
+
});
|
|
5208
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5787
5209
|
}
|
|
5788
|
-
const message = response.message || response.Message || errorCode;
|
|
5789
|
-
response.message = message;
|
|
5790
|
-
delete response.Message;
|
|
5791
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5792
5210
|
};
|
|
5793
5211
|
const deserializeAws_restJson1GetResourceDefinitionCommand = async (output, context) => {
|
|
5794
5212
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5844,27 +5262,16 @@ const deserializeAws_restJson1GetResourceDefinitionCommandError = async (output,
|
|
|
5844
5262
|
switch (errorCode) {
|
|
5845
5263
|
case "BadRequestException":
|
|
5846
5264
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5847
|
-
|
|
5848
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5849
|
-
name: errorCode,
|
|
5850
|
-
$metadata: deserializeMetadata(output),
|
|
5851
|
-
};
|
|
5852
|
-
break;
|
|
5265
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5853
5266
|
default:
|
|
5854
5267
|
const parsedBody = parsedOutput.body;
|
|
5855
|
-
|
|
5856
|
-
|
|
5857
|
-
...parsedBody,
|
|
5858
|
-
name: `${errorCode}`,
|
|
5859
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5268
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5269
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5860
5270
|
$fault: "client",
|
|
5861
5271
|
$metadata: deserializeMetadata(output),
|
|
5862
|
-
};
|
|
5272
|
+
});
|
|
5273
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5863
5274
|
}
|
|
5864
|
-
const message = response.message || response.Message || errorCode;
|
|
5865
|
-
response.message = message;
|
|
5866
|
-
delete response.Message;
|
|
5867
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5868
5275
|
};
|
|
5869
5276
|
const deserializeAws_restJson1GetResourceDefinitionVersionCommand = async (output, context) => {
|
|
5870
5277
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5908,27 +5315,16 @@ const deserializeAws_restJson1GetResourceDefinitionVersionCommandError = async (
|
|
|
5908
5315
|
switch (errorCode) {
|
|
5909
5316
|
case "BadRequestException":
|
|
5910
5317
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
5911
|
-
|
|
5912
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
5913
|
-
name: errorCode,
|
|
5914
|
-
$metadata: deserializeMetadata(output),
|
|
5915
|
-
};
|
|
5916
|
-
break;
|
|
5318
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
5917
5319
|
default:
|
|
5918
5320
|
const parsedBody = parsedOutput.body;
|
|
5919
|
-
|
|
5920
|
-
|
|
5921
|
-
...parsedBody,
|
|
5922
|
-
name: `${errorCode}`,
|
|
5923
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5321
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5322
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5924
5323
|
$fault: "client",
|
|
5925
5324
|
$metadata: deserializeMetadata(output),
|
|
5926
|
-
};
|
|
5325
|
+
});
|
|
5326
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5927
5327
|
}
|
|
5928
|
-
const message = response.message || response.Message || errorCode;
|
|
5929
|
-
response.message = message;
|
|
5930
|
-
delete response.Message;
|
|
5931
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5932
5328
|
};
|
|
5933
5329
|
const deserializeAws_restJson1GetServiceRoleForAccountCommand = async (output, context) => {
|
|
5934
5330
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -5960,27 +5356,16 @@ const deserializeAws_restJson1GetServiceRoleForAccountCommandError = async (outp
|
|
|
5960
5356
|
switch (errorCode) {
|
|
5961
5357
|
case "InternalServerErrorException":
|
|
5962
5358
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
5963
|
-
|
|
5964
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
5965
|
-
name: errorCode,
|
|
5966
|
-
$metadata: deserializeMetadata(output),
|
|
5967
|
-
};
|
|
5968
|
-
break;
|
|
5359
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
5969
5360
|
default:
|
|
5970
5361
|
const parsedBody = parsedOutput.body;
|
|
5971
|
-
|
|
5972
|
-
|
|
5973
|
-
...parsedBody,
|
|
5974
|
-
name: `${errorCode}`,
|
|
5975
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5362
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5363
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5976
5364
|
$fault: "client",
|
|
5977
5365
|
$metadata: deserializeMetadata(output),
|
|
5978
|
-
};
|
|
5366
|
+
});
|
|
5367
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5979
5368
|
}
|
|
5980
|
-
const message = response.message || response.Message || errorCode;
|
|
5981
|
-
response.message = message;
|
|
5982
|
-
delete response.Message;
|
|
5983
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5984
5369
|
};
|
|
5985
5370
|
const deserializeAws_restJson1GetSubscriptionDefinitionCommand = async (output, context) => {
|
|
5986
5371
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6036,27 +5421,16 @@ const deserializeAws_restJson1GetSubscriptionDefinitionCommandError = async (out
|
|
|
6036
5421
|
switch (errorCode) {
|
|
6037
5422
|
case "BadRequestException":
|
|
6038
5423
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6039
|
-
|
|
6040
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6041
|
-
name: errorCode,
|
|
6042
|
-
$metadata: deserializeMetadata(output),
|
|
6043
|
-
};
|
|
6044
|
-
break;
|
|
5424
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6045
5425
|
default:
|
|
6046
5426
|
const parsedBody = parsedOutput.body;
|
|
6047
|
-
|
|
6048
|
-
|
|
6049
|
-
...parsedBody,
|
|
6050
|
-
name: `${errorCode}`,
|
|
6051
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5427
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5428
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6052
5429
|
$fault: "client",
|
|
6053
5430
|
$metadata: deserializeMetadata(output),
|
|
6054
|
-
};
|
|
5431
|
+
});
|
|
5432
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6055
5433
|
}
|
|
6056
|
-
const message = response.message || response.Message || errorCode;
|
|
6057
|
-
response.message = message;
|
|
6058
|
-
delete response.Message;
|
|
6059
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6060
5434
|
};
|
|
6061
5435
|
const deserializeAws_restJson1GetSubscriptionDefinitionVersionCommand = async (output, context) => {
|
|
6062
5436
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6104,27 +5478,16 @@ const deserializeAws_restJson1GetSubscriptionDefinitionVersionCommandError = asy
|
|
|
6104
5478
|
switch (errorCode) {
|
|
6105
5479
|
case "BadRequestException":
|
|
6106
5480
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6107
|
-
|
|
6108
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6109
|
-
name: errorCode,
|
|
6110
|
-
$metadata: deserializeMetadata(output),
|
|
6111
|
-
};
|
|
6112
|
-
break;
|
|
5481
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6113
5482
|
default:
|
|
6114
5483
|
const parsedBody = parsedOutput.body;
|
|
6115
|
-
|
|
6116
|
-
|
|
6117
|
-
...parsedBody,
|
|
6118
|
-
name: `${errorCode}`,
|
|
6119
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5484
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5485
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6120
5486
|
$fault: "client",
|
|
6121
5487
|
$metadata: deserializeMetadata(output),
|
|
6122
|
-
};
|
|
5488
|
+
});
|
|
5489
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6123
5490
|
}
|
|
6124
|
-
const message = response.message || response.Message || errorCode;
|
|
6125
|
-
response.message = message;
|
|
6126
|
-
delete response.Message;
|
|
6127
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6128
5491
|
};
|
|
6129
5492
|
const deserializeAws_restJson1GetThingRuntimeConfigurationCommand = async (output, context) => {
|
|
6130
5493
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6152,35 +5515,19 @@ const deserializeAws_restJson1GetThingRuntimeConfigurationCommandError = async (
|
|
|
6152
5515
|
switch (errorCode) {
|
|
6153
5516
|
case "BadRequestException":
|
|
6154
5517
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6155
|
-
|
|
6156
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6157
|
-
name: errorCode,
|
|
6158
|
-
$metadata: deserializeMetadata(output),
|
|
6159
|
-
};
|
|
6160
|
-
break;
|
|
5518
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6161
5519
|
case "InternalServerErrorException":
|
|
6162
5520
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
6163
|
-
|
|
6164
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
6165
|
-
name: errorCode,
|
|
6166
|
-
$metadata: deserializeMetadata(output),
|
|
6167
|
-
};
|
|
6168
|
-
break;
|
|
5521
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
6169
5522
|
default:
|
|
6170
5523
|
const parsedBody = parsedOutput.body;
|
|
6171
|
-
|
|
6172
|
-
|
|
6173
|
-
...parsedBody,
|
|
6174
|
-
name: `${errorCode}`,
|
|
6175
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5524
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5525
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6176
5526
|
$fault: "client",
|
|
6177
5527
|
$metadata: deserializeMetadata(output),
|
|
6178
|
-
};
|
|
5528
|
+
});
|
|
5529
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6179
5530
|
}
|
|
6180
|
-
const message = response.message || response.Message || errorCode;
|
|
6181
|
-
response.message = message;
|
|
6182
|
-
delete response.Message;
|
|
6183
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6184
5531
|
};
|
|
6185
5532
|
const deserializeAws_restJson1ListBulkDeploymentDetailedReportsCommand = async (output, context) => {
|
|
6186
5533
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6212,27 +5559,16 @@ const deserializeAws_restJson1ListBulkDeploymentDetailedReportsCommandError = as
|
|
|
6212
5559
|
switch (errorCode) {
|
|
6213
5560
|
case "BadRequestException":
|
|
6214
5561
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6215
|
-
|
|
6216
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6217
|
-
name: errorCode,
|
|
6218
|
-
$metadata: deserializeMetadata(output),
|
|
6219
|
-
};
|
|
6220
|
-
break;
|
|
5562
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6221
5563
|
default:
|
|
6222
5564
|
const parsedBody = parsedOutput.body;
|
|
6223
|
-
|
|
6224
|
-
|
|
6225
|
-
...parsedBody,
|
|
6226
|
-
name: `${errorCode}`,
|
|
6227
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5565
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5566
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6228
5567
|
$fault: "client",
|
|
6229
5568
|
$metadata: deserializeMetadata(output),
|
|
6230
|
-
};
|
|
5569
|
+
});
|
|
5570
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6231
5571
|
}
|
|
6232
|
-
const message = response.message || response.Message || errorCode;
|
|
6233
|
-
response.message = message;
|
|
6234
|
-
delete response.Message;
|
|
6235
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6236
5572
|
};
|
|
6237
5573
|
const deserializeAws_restJson1ListBulkDeploymentsCommand = async (output, context) => {
|
|
6238
5574
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6264,27 +5600,16 @@ const deserializeAws_restJson1ListBulkDeploymentsCommandError = async (output, c
|
|
|
6264
5600
|
switch (errorCode) {
|
|
6265
5601
|
case "BadRequestException":
|
|
6266
5602
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6267
|
-
|
|
6268
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6269
|
-
name: errorCode,
|
|
6270
|
-
$metadata: deserializeMetadata(output),
|
|
6271
|
-
};
|
|
6272
|
-
break;
|
|
5603
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6273
5604
|
default:
|
|
6274
5605
|
const parsedBody = parsedOutput.body;
|
|
6275
|
-
|
|
6276
|
-
|
|
6277
|
-
...parsedBody,
|
|
6278
|
-
name: `${errorCode}`,
|
|
6279
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5606
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5607
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6280
5608
|
$fault: "client",
|
|
6281
5609
|
$metadata: deserializeMetadata(output),
|
|
6282
|
-
};
|
|
5610
|
+
});
|
|
5611
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6283
5612
|
}
|
|
6284
|
-
const message = response.message || response.Message || errorCode;
|
|
6285
|
-
response.message = message;
|
|
6286
|
-
delete response.Message;
|
|
6287
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6288
5613
|
};
|
|
6289
5614
|
const deserializeAws_restJson1ListConnectorDefinitionsCommand = async (output, context) => {
|
|
6290
5615
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6316,19 +5641,13 @@ const deserializeAws_restJson1ListConnectorDefinitionsCommandError = async (outp
|
|
|
6316
5641
|
switch (errorCode) {
|
|
6317
5642
|
default:
|
|
6318
5643
|
const parsedBody = parsedOutput.body;
|
|
6319
|
-
|
|
6320
|
-
|
|
6321
|
-
...parsedBody,
|
|
6322
|
-
name: `${errorCode}`,
|
|
6323
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5644
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5645
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6324
5646
|
$fault: "client",
|
|
6325
5647
|
$metadata: deserializeMetadata(output),
|
|
6326
|
-
};
|
|
5648
|
+
});
|
|
5649
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6327
5650
|
}
|
|
6328
|
-
const message = response.message || response.Message || errorCode;
|
|
6329
|
-
response.message = message;
|
|
6330
|
-
delete response.Message;
|
|
6331
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6332
5651
|
};
|
|
6333
5652
|
const deserializeAws_restJson1ListConnectorDefinitionVersionsCommand = async (output, context) => {
|
|
6334
5653
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6360,27 +5679,16 @@ const deserializeAws_restJson1ListConnectorDefinitionVersionsCommandError = asyn
|
|
|
6360
5679
|
switch (errorCode) {
|
|
6361
5680
|
case "BadRequestException":
|
|
6362
5681
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6363
|
-
|
|
6364
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6365
|
-
name: errorCode,
|
|
6366
|
-
$metadata: deserializeMetadata(output),
|
|
6367
|
-
};
|
|
6368
|
-
break;
|
|
5682
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6369
5683
|
default:
|
|
6370
5684
|
const parsedBody = parsedOutput.body;
|
|
6371
|
-
|
|
6372
|
-
|
|
6373
|
-
...parsedBody,
|
|
6374
|
-
name: `${errorCode}`,
|
|
6375
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5685
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5686
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6376
5687
|
$fault: "client",
|
|
6377
5688
|
$metadata: deserializeMetadata(output),
|
|
6378
|
-
};
|
|
5689
|
+
});
|
|
5690
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6379
5691
|
}
|
|
6380
|
-
const message = response.message || response.Message || errorCode;
|
|
6381
|
-
response.message = message;
|
|
6382
|
-
delete response.Message;
|
|
6383
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6384
5692
|
};
|
|
6385
5693
|
const deserializeAws_restJson1ListCoreDefinitionsCommand = async (output, context) => {
|
|
6386
5694
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6412,19 +5720,13 @@ const deserializeAws_restJson1ListCoreDefinitionsCommandError = async (output, c
|
|
|
6412
5720
|
switch (errorCode) {
|
|
6413
5721
|
default:
|
|
6414
5722
|
const parsedBody = parsedOutput.body;
|
|
6415
|
-
|
|
6416
|
-
|
|
6417
|
-
...parsedBody,
|
|
6418
|
-
name: `${errorCode}`,
|
|
6419
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5723
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5724
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6420
5725
|
$fault: "client",
|
|
6421
5726
|
$metadata: deserializeMetadata(output),
|
|
6422
|
-
};
|
|
5727
|
+
});
|
|
5728
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6423
5729
|
}
|
|
6424
|
-
const message = response.message || response.Message || errorCode;
|
|
6425
|
-
response.message = message;
|
|
6426
|
-
delete response.Message;
|
|
6427
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6428
5730
|
};
|
|
6429
5731
|
const deserializeAws_restJson1ListCoreDefinitionVersionsCommand = async (output, context) => {
|
|
6430
5732
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6456,27 +5758,16 @@ const deserializeAws_restJson1ListCoreDefinitionVersionsCommandError = async (ou
|
|
|
6456
5758
|
switch (errorCode) {
|
|
6457
5759
|
case "BadRequestException":
|
|
6458
5760
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6459
|
-
|
|
6460
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6461
|
-
name: errorCode,
|
|
6462
|
-
$metadata: deserializeMetadata(output),
|
|
6463
|
-
};
|
|
6464
|
-
break;
|
|
5761
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6465
5762
|
default:
|
|
6466
5763
|
const parsedBody = parsedOutput.body;
|
|
6467
|
-
|
|
6468
|
-
|
|
6469
|
-
...parsedBody,
|
|
6470
|
-
name: `${errorCode}`,
|
|
6471
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5764
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5765
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6472
5766
|
$fault: "client",
|
|
6473
5767
|
$metadata: deserializeMetadata(output),
|
|
6474
|
-
};
|
|
5768
|
+
});
|
|
5769
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6475
5770
|
}
|
|
6476
|
-
const message = response.message || response.Message || errorCode;
|
|
6477
|
-
response.message = message;
|
|
6478
|
-
delete response.Message;
|
|
6479
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6480
5771
|
};
|
|
6481
5772
|
const deserializeAws_restJson1ListDeploymentsCommand = async (output, context) => {
|
|
6482
5773
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6508,27 +5799,16 @@ const deserializeAws_restJson1ListDeploymentsCommandError = async (output, conte
|
|
|
6508
5799
|
switch (errorCode) {
|
|
6509
5800
|
case "BadRequestException":
|
|
6510
5801
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6511
|
-
|
|
6512
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6513
|
-
name: errorCode,
|
|
6514
|
-
$metadata: deserializeMetadata(output),
|
|
6515
|
-
};
|
|
6516
|
-
break;
|
|
5802
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6517
5803
|
default:
|
|
6518
5804
|
const parsedBody = parsedOutput.body;
|
|
6519
|
-
|
|
6520
|
-
|
|
6521
|
-
...parsedBody,
|
|
6522
|
-
name: `${errorCode}`,
|
|
6523
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5805
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5806
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6524
5807
|
$fault: "client",
|
|
6525
5808
|
$metadata: deserializeMetadata(output),
|
|
6526
|
-
};
|
|
5809
|
+
});
|
|
5810
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6527
5811
|
}
|
|
6528
|
-
const message = response.message || response.Message || errorCode;
|
|
6529
|
-
response.message = message;
|
|
6530
|
-
delete response.Message;
|
|
6531
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6532
5812
|
};
|
|
6533
5813
|
const deserializeAws_restJson1ListDeviceDefinitionsCommand = async (output, context) => {
|
|
6534
5814
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6560,19 +5840,13 @@ const deserializeAws_restJson1ListDeviceDefinitionsCommandError = async (output,
|
|
|
6560
5840
|
switch (errorCode) {
|
|
6561
5841
|
default:
|
|
6562
5842
|
const parsedBody = parsedOutput.body;
|
|
6563
|
-
|
|
6564
|
-
|
|
6565
|
-
...parsedBody,
|
|
6566
|
-
name: `${errorCode}`,
|
|
6567
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5843
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5844
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6568
5845
|
$fault: "client",
|
|
6569
5846
|
$metadata: deserializeMetadata(output),
|
|
6570
|
-
};
|
|
5847
|
+
});
|
|
5848
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6571
5849
|
}
|
|
6572
|
-
const message = response.message || response.Message || errorCode;
|
|
6573
|
-
response.message = message;
|
|
6574
|
-
delete response.Message;
|
|
6575
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6576
5850
|
};
|
|
6577
5851
|
const deserializeAws_restJson1ListDeviceDefinitionVersionsCommand = async (output, context) => {
|
|
6578
5852
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6604,27 +5878,16 @@ const deserializeAws_restJson1ListDeviceDefinitionVersionsCommandError = async (
|
|
|
6604
5878
|
switch (errorCode) {
|
|
6605
5879
|
case "BadRequestException":
|
|
6606
5880
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6607
|
-
|
|
6608
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6609
|
-
name: errorCode,
|
|
6610
|
-
$metadata: deserializeMetadata(output),
|
|
6611
|
-
};
|
|
6612
|
-
break;
|
|
5881
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6613
5882
|
default:
|
|
6614
5883
|
const parsedBody = parsedOutput.body;
|
|
6615
|
-
|
|
6616
|
-
|
|
6617
|
-
...parsedBody,
|
|
6618
|
-
name: `${errorCode}`,
|
|
6619
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5884
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5885
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6620
5886
|
$fault: "client",
|
|
6621
5887
|
$metadata: deserializeMetadata(output),
|
|
6622
|
-
};
|
|
5888
|
+
});
|
|
5889
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6623
5890
|
}
|
|
6624
|
-
const message = response.message || response.Message || errorCode;
|
|
6625
|
-
response.message = message;
|
|
6626
|
-
delete response.Message;
|
|
6627
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6628
5891
|
};
|
|
6629
5892
|
const deserializeAws_restJson1ListFunctionDefinitionsCommand = async (output, context) => {
|
|
6630
5893
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6656,19 +5919,13 @@ const deserializeAws_restJson1ListFunctionDefinitionsCommandError = async (outpu
|
|
|
6656
5919
|
switch (errorCode) {
|
|
6657
5920
|
default:
|
|
6658
5921
|
const parsedBody = parsedOutput.body;
|
|
6659
|
-
|
|
6660
|
-
|
|
6661
|
-
...parsedBody,
|
|
6662
|
-
name: `${errorCode}`,
|
|
6663
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5922
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5923
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6664
5924
|
$fault: "client",
|
|
6665
5925
|
$metadata: deserializeMetadata(output),
|
|
6666
|
-
};
|
|
5926
|
+
});
|
|
5927
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6667
5928
|
}
|
|
6668
|
-
const message = response.message || response.Message || errorCode;
|
|
6669
|
-
response.message = message;
|
|
6670
|
-
delete response.Message;
|
|
6671
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6672
5929
|
};
|
|
6673
5930
|
const deserializeAws_restJson1ListFunctionDefinitionVersionsCommand = async (output, context) => {
|
|
6674
5931
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6700,27 +5957,16 @@ const deserializeAws_restJson1ListFunctionDefinitionVersionsCommandError = async
|
|
|
6700
5957
|
switch (errorCode) {
|
|
6701
5958
|
case "BadRequestException":
|
|
6702
5959
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6703
|
-
|
|
6704
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6705
|
-
name: errorCode,
|
|
6706
|
-
$metadata: deserializeMetadata(output),
|
|
6707
|
-
};
|
|
6708
|
-
break;
|
|
5960
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6709
5961
|
default:
|
|
6710
5962
|
const parsedBody = parsedOutput.body;
|
|
6711
|
-
|
|
6712
|
-
|
|
6713
|
-
...parsedBody,
|
|
6714
|
-
name: `${errorCode}`,
|
|
6715
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
5963
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
5964
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6716
5965
|
$fault: "client",
|
|
6717
5966
|
$metadata: deserializeMetadata(output),
|
|
6718
|
-
};
|
|
5967
|
+
});
|
|
5968
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6719
5969
|
}
|
|
6720
|
-
const message = response.message || response.Message || errorCode;
|
|
6721
|
-
response.message = message;
|
|
6722
|
-
delete response.Message;
|
|
6723
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6724
5970
|
};
|
|
6725
5971
|
const deserializeAws_restJson1ListGroupCertificateAuthoritiesCommand = async (output, context) => {
|
|
6726
5972
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6748,35 +5994,19 @@ const deserializeAws_restJson1ListGroupCertificateAuthoritiesCommandError = asyn
|
|
|
6748
5994
|
switch (errorCode) {
|
|
6749
5995
|
case "BadRequestException":
|
|
6750
5996
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6751
|
-
|
|
6752
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6753
|
-
name: errorCode,
|
|
6754
|
-
$metadata: deserializeMetadata(output),
|
|
6755
|
-
};
|
|
6756
|
-
break;
|
|
5997
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6757
5998
|
case "InternalServerErrorException":
|
|
6758
5999
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
6759
|
-
|
|
6760
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
6761
|
-
name: errorCode,
|
|
6762
|
-
$metadata: deserializeMetadata(output),
|
|
6763
|
-
};
|
|
6764
|
-
break;
|
|
6000
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
6765
6001
|
default:
|
|
6766
6002
|
const parsedBody = parsedOutput.body;
|
|
6767
|
-
|
|
6768
|
-
|
|
6769
|
-
...parsedBody,
|
|
6770
|
-
name: `${errorCode}`,
|
|
6771
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6003
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6004
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6772
6005
|
$fault: "client",
|
|
6773
6006
|
$metadata: deserializeMetadata(output),
|
|
6774
|
-
};
|
|
6007
|
+
});
|
|
6008
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6775
6009
|
}
|
|
6776
|
-
const message = response.message || response.Message || errorCode;
|
|
6777
|
-
response.message = message;
|
|
6778
|
-
delete response.Message;
|
|
6779
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6780
6010
|
};
|
|
6781
6011
|
const deserializeAws_restJson1ListGroupsCommand = async (output, context) => {
|
|
6782
6012
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6808,19 +6038,13 @@ const deserializeAws_restJson1ListGroupsCommandError = async (output, context) =
|
|
|
6808
6038
|
switch (errorCode) {
|
|
6809
6039
|
default:
|
|
6810
6040
|
const parsedBody = parsedOutput.body;
|
|
6811
|
-
|
|
6812
|
-
|
|
6813
|
-
...parsedBody,
|
|
6814
|
-
name: `${errorCode}`,
|
|
6815
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6041
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6042
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6816
6043
|
$fault: "client",
|
|
6817
6044
|
$metadata: deserializeMetadata(output),
|
|
6818
|
-
};
|
|
6045
|
+
});
|
|
6046
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6819
6047
|
}
|
|
6820
|
-
const message = response.message || response.Message || errorCode;
|
|
6821
|
-
response.message = message;
|
|
6822
|
-
delete response.Message;
|
|
6823
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6824
6048
|
};
|
|
6825
6049
|
const deserializeAws_restJson1ListGroupVersionsCommand = async (output, context) => {
|
|
6826
6050
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6852,27 +6076,16 @@ const deserializeAws_restJson1ListGroupVersionsCommandError = async (output, con
|
|
|
6852
6076
|
switch (errorCode) {
|
|
6853
6077
|
case "BadRequestException":
|
|
6854
6078
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6855
|
-
|
|
6856
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6857
|
-
name: errorCode,
|
|
6858
|
-
$metadata: deserializeMetadata(output),
|
|
6859
|
-
};
|
|
6860
|
-
break;
|
|
6079
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6861
6080
|
default:
|
|
6862
6081
|
const parsedBody = parsedOutput.body;
|
|
6863
|
-
|
|
6864
|
-
|
|
6865
|
-
...parsedBody,
|
|
6866
|
-
name: `${errorCode}`,
|
|
6867
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6082
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6083
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6868
6084
|
$fault: "client",
|
|
6869
6085
|
$metadata: deserializeMetadata(output),
|
|
6870
|
-
};
|
|
6086
|
+
});
|
|
6087
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6871
6088
|
}
|
|
6872
|
-
const message = response.message || response.Message || errorCode;
|
|
6873
|
-
response.message = message;
|
|
6874
|
-
delete response.Message;
|
|
6875
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6876
6089
|
};
|
|
6877
6090
|
const deserializeAws_restJson1ListLoggerDefinitionsCommand = async (output, context) => {
|
|
6878
6091
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6904,19 +6117,13 @@ const deserializeAws_restJson1ListLoggerDefinitionsCommandError = async (output,
|
|
|
6904
6117
|
switch (errorCode) {
|
|
6905
6118
|
default:
|
|
6906
6119
|
const parsedBody = parsedOutput.body;
|
|
6907
|
-
|
|
6908
|
-
|
|
6909
|
-
...parsedBody,
|
|
6910
|
-
name: `${errorCode}`,
|
|
6911
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6120
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6121
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6912
6122
|
$fault: "client",
|
|
6913
6123
|
$metadata: deserializeMetadata(output),
|
|
6914
|
-
};
|
|
6124
|
+
});
|
|
6125
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6915
6126
|
}
|
|
6916
|
-
const message = response.message || response.Message || errorCode;
|
|
6917
|
-
response.message = message;
|
|
6918
|
-
delete response.Message;
|
|
6919
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6920
6127
|
};
|
|
6921
6128
|
const deserializeAws_restJson1ListLoggerDefinitionVersionsCommand = async (output, context) => {
|
|
6922
6129
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -6948,27 +6155,16 @@ const deserializeAws_restJson1ListLoggerDefinitionVersionsCommandError = async (
|
|
|
6948
6155
|
switch (errorCode) {
|
|
6949
6156
|
case "BadRequestException":
|
|
6950
6157
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
6951
|
-
|
|
6952
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
6953
|
-
name: errorCode,
|
|
6954
|
-
$metadata: deserializeMetadata(output),
|
|
6955
|
-
};
|
|
6956
|
-
break;
|
|
6158
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
6957
6159
|
default:
|
|
6958
6160
|
const parsedBody = parsedOutput.body;
|
|
6959
|
-
|
|
6960
|
-
|
|
6961
|
-
...parsedBody,
|
|
6962
|
-
name: `${errorCode}`,
|
|
6963
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6161
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6162
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
6964
6163
|
$fault: "client",
|
|
6965
6164
|
$metadata: deserializeMetadata(output),
|
|
6966
|
-
};
|
|
6165
|
+
});
|
|
6166
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
6967
6167
|
}
|
|
6968
|
-
const message = response.message || response.Message || errorCode;
|
|
6969
|
-
response.message = message;
|
|
6970
|
-
delete response.Message;
|
|
6971
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
6972
6168
|
};
|
|
6973
6169
|
const deserializeAws_restJson1ListResourceDefinitionsCommand = async (output, context) => {
|
|
6974
6170
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7000,19 +6196,13 @@ const deserializeAws_restJson1ListResourceDefinitionsCommandError = async (outpu
|
|
|
7000
6196
|
switch (errorCode) {
|
|
7001
6197
|
default:
|
|
7002
6198
|
const parsedBody = parsedOutput.body;
|
|
7003
|
-
|
|
7004
|
-
|
|
7005
|
-
...parsedBody,
|
|
7006
|
-
name: `${errorCode}`,
|
|
7007
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6199
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6200
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7008
6201
|
$fault: "client",
|
|
7009
6202
|
$metadata: deserializeMetadata(output),
|
|
7010
|
-
};
|
|
6203
|
+
});
|
|
6204
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7011
6205
|
}
|
|
7012
|
-
const message = response.message || response.Message || errorCode;
|
|
7013
|
-
response.message = message;
|
|
7014
|
-
delete response.Message;
|
|
7015
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7016
6206
|
};
|
|
7017
6207
|
const deserializeAws_restJson1ListResourceDefinitionVersionsCommand = async (output, context) => {
|
|
7018
6208
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7044,27 +6234,16 @@ const deserializeAws_restJson1ListResourceDefinitionVersionsCommandError = async
|
|
|
7044
6234
|
switch (errorCode) {
|
|
7045
6235
|
case "BadRequestException":
|
|
7046
6236
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7047
|
-
|
|
7048
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7049
|
-
name: errorCode,
|
|
7050
|
-
$metadata: deserializeMetadata(output),
|
|
7051
|
-
};
|
|
7052
|
-
break;
|
|
6237
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7053
6238
|
default:
|
|
7054
6239
|
const parsedBody = parsedOutput.body;
|
|
7055
|
-
|
|
7056
|
-
|
|
7057
|
-
...parsedBody,
|
|
7058
|
-
name: `${errorCode}`,
|
|
7059
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6240
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6241
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7060
6242
|
$fault: "client",
|
|
7061
6243
|
$metadata: deserializeMetadata(output),
|
|
7062
|
-
};
|
|
6244
|
+
});
|
|
6245
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7063
6246
|
}
|
|
7064
|
-
const message = response.message || response.Message || errorCode;
|
|
7065
|
-
response.message = message;
|
|
7066
|
-
delete response.Message;
|
|
7067
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7068
6247
|
};
|
|
7069
6248
|
const deserializeAws_restJson1ListSubscriptionDefinitionsCommand = async (output, context) => {
|
|
7070
6249
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7096,19 +6275,13 @@ const deserializeAws_restJson1ListSubscriptionDefinitionsCommandError = async (o
|
|
|
7096
6275
|
switch (errorCode) {
|
|
7097
6276
|
default:
|
|
7098
6277
|
const parsedBody = parsedOutput.body;
|
|
7099
|
-
|
|
7100
|
-
|
|
7101
|
-
...parsedBody,
|
|
7102
|
-
name: `${errorCode}`,
|
|
7103
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6278
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6279
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7104
6280
|
$fault: "client",
|
|
7105
6281
|
$metadata: deserializeMetadata(output),
|
|
7106
|
-
};
|
|
6282
|
+
});
|
|
6283
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7107
6284
|
}
|
|
7108
|
-
const message = response.message || response.Message || errorCode;
|
|
7109
|
-
response.message = message;
|
|
7110
|
-
delete response.Message;
|
|
7111
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7112
6285
|
};
|
|
7113
6286
|
const deserializeAws_restJson1ListSubscriptionDefinitionVersionsCommand = async (output, context) => {
|
|
7114
6287
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7140,27 +6313,16 @@ const deserializeAws_restJson1ListSubscriptionDefinitionVersionsCommandError = a
|
|
|
7140
6313
|
switch (errorCode) {
|
|
7141
6314
|
case "BadRequestException":
|
|
7142
6315
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7143
|
-
|
|
7144
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7145
|
-
name: errorCode,
|
|
7146
|
-
$metadata: deserializeMetadata(output),
|
|
7147
|
-
};
|
|
7148
|
-
break;
|
|
6316
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7149
6317
|
default:
|
|
7150
6318
|
const parsedBody = parsedOutput.body;
|
|
7151
|
-
|
|
7152
|
-
|
|
7153
|
-
...parsedBody,
|
|
7154
|
-
name: `${errorCode}`,
|
|
7155
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6319
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6320
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7156
6321
|
$fault: "client",
|
|
7157
6322
|
$metadata: deserializeMetadata(output),
|
|
7158
|
-
};
|
|
6323
|
+
});
|
|
6324
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7159
6325
|
}
|
|
7160
|
-
const message = response.message || response.Message || errorCode;
|
|
7161
|
-
response.message = message;
|
|
7162
|
-
delete response.Message;
|
|
7163
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7164
6326
|
};
|
|
7165
6327
|
const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
|
|
7166
6328
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7188,27 +6350,16 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
|
|
|
7188
6350
|
switch (errorCode) {
|
|
7189
6351
|
case "BadRequestException":
|
|
7190
6352
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7191
|
-
|
|
7192
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7193
|
-
name: errorCode,
|
|
7194
|
-
$metadata: deserializeMetadata(output),
|
|
7195
|
-
};
|
|
7196
|
-
break;
|
|
6353
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7197
6354
|
default:
|
|
7198
6355
|
const parsedBody = parsedOutput.body;
|
|
7199
|
-
|
|
7200
|
-
|
|
7201
|
-
...parsedBody,
|
|
7202
|
-
name: `${errorCode}`,
|
|
7203
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6356
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6357
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7204
6358
|
$fault: "client",
|
|
7205
6359
|
$metadata: deserializeMetadata(output),
|
|
7206
|
-
};
|
|
6360
|
+
});
|
|
6361
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7207
6362
|
}
|
|
7208
|
-
const message = response.message || response.Message || errorCode;
|
|
7209
|
-
response.message = message;
|
|
7210
|
-
delete response.Message;
|
|
7211
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7212
6363
|
};
|
|
7213
6364
|
const deserializeAws_restJson1ResetDeploymentsCommand = async (output, context) => {
|
|
7214
6365
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7240,27 +6391,16 @@ const deserializeAws_restJson1ResetDeploymentsCommandError = async (output, cont
|
|
|
7240
6391
|
switch (errorCode) {
|
|
7241
6392
|
case "BadRequestException":
|
|
7242
6393
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7243
|
-
|
|
7244
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7245
|
-
name: errorCode,
|
|
7246
|
-
$metadata: deserializeMetadata(output),
|
|
7247
|
-
};
|
|
7248
|
-
break;
|
|
6394
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7249
6395
|
default:
|
|
7250
6396
|
const parsedBody = parsedOutput.body;
|
|
7251
|
-
|
|
7252
|
-
|
|
7253
|
-
...parsedBody,
|
|
7254
|
-
name: `${errorCode}`,
|
|
7255
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6397
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6398
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7256
6399
|
$fault: "client",
|
|
7257
6400
|
$metadata: deserializeMetadata(output),
|
|
7258
|
-
};
|
|
6401
|
+
});
|
|
6402
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7259
6403
|
}
|
|
7260
|
-
const message = response.message || response.Message || errorCode;
|
|
7261
|
-
response.message = message;
|
|
7262
|
-
delete response.Message;
|
|
7263
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7264
6404
|
};
|
|
7265
6405
|
const deserializeAws_restJson1StartBulkDeploymentCommand = async (output, context) => {
|
|
7266
6406
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7292,27 +6432,16 @@ const deserializeAws_restJson1StartBulkDeploymentCommandError = async (output, c
|
|
|
7292
6432
|
switch (errorCode) {
|
|
7293
6433
|
case "BadRequestException":
|
|
7294
6434
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7295
|
-
|
|
7296
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7297
|
-
name: errorCode,
|
|
7298
|
-
$metadata: deserializeMetadata(output),
|
|
7299
|
-
};
|
|
7300
|
-
break;
|
|
6435
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7301
6436
|
default:
|
|
7302
6437
|
const parsedBody = parsedOutput.body;
|
|
7303
|
-
|
|
7304
|
-
|
|
7305
|
-
...parsedBody,
|
|
7306
|
-
name: `${errorCode}`,
|
|
7307
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6438
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6439
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7308
6440
|
$fault: "client",
|
|
7309
6441
|
$metadata: deserializeMetadata(output),
|
|
7310
|
-
};
|
|
6442
|
+
});
|
|
6443
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7311
6444
|
}
|
|
7312
|
-
const message = response.message || response.Message || errorCode;
|
|
7313
|
-
response.message = message;
|
|
7314
|
-
delete response.Message;
|
|
7315
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7316
6445
|
};
|
|
7317
6446
|
const deserializeAws_restJson1StopBulkDeploymentCommand = async (output, context) => {
|
|
7318
6447
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7336,27 +6465,16 @@ const deserializeAws_restJson1StopBulkDeploymentCommandError = async (output, co
|
|
|
7336
6465
|
switch (errorCode) {
|
|
7337
6466
|
case "BadRequestException":
|
|
7338
6467
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7339
|
-
|
|
7340
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7341
|
-
name: errorCode,
|
|
7342
|
-
$metadata: deserializeMetadata(output),
|
|
7343
|
-
};
|
|
7344
|
-
break;
|
|
6468
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7345
6469
|
default:
|
|
7346
6470
|
const parsedBody = parsedOutput.body;
|
|
7347
|
-
|
|
7348
|
-
|
|
7349
|
-
...parsedBody,
|
|
7350
|
-
name: `${errorCode}`,
|
|
7351
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6471
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6472
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7352
6473
|
$fault: "client",
|
|
7353
6474
|
$metadata: deserializeMetadata(output),
|
|
7354
|
-
};
|
|
6475
|
+
});
|
|
6476
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7355
6477
|
}
|
|
7356
|
-
const message = response.message || response.Message || errorCode;
|
|
7357
|
-
response.message = message;
|
|
7358
|
-
delete response.Message;
|
|
7359
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7360
6478
|
};
|
|
7361
6479
|
const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
|
|
7362
6480
|
if (output.statusCode !== 204 && output.statusCode >= 300) {
|
|
@@ -7380,27 +6498,16 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
|
|
|
7380
6498
|
switch (errorCode) {
|
|
7381
6499
|
case "BadRequestException":
|
|
7382
6500
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7383
|
-
|
|
7384
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7385
|
-
name: errorCode,
|
|
7386
|
-
$metadata: deserializeMetadata(output),
|
|
7387
|
-
};
|
|
7388
|
-
break;
|
|
6501
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7389
6502
|
default:
|
|
7390
6503
|
const parsedBody = parsedOutput.body;
|
|
7391
|
-
|
|
7392
|
-
|
|
7393
|
-
...parsedBody,
|
|
7394
|
-
name: `${errorCode}`,
|
|
7395
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6504
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6505
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7396
6506
|
$fault: "client",
|
|
7397
6507
|
$metadata: deserializeMetadata(output),
|
|
7398
|
-
};
|
|
6508
|
+
});
|
|
6509
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7399
6510
|
}
|
|
7400
|
-
const message = response.message || response.Message || errorCode;
|
|
7401
|
-
response.message = message;
|
|
7402
|
-
delete response.Message;
|
|
7403
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7404
6511
|
};
|
|
7405
6512
|
const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
|
|
7406
6513
|
if (output.statusCode !== 204 && output.statusCode >= 300) {
|
|
@@ -7424,27 +6531,16 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
|
|
|
7424
6531
|
switch (errorCode) {
|
|
7425
6532
|
case "BadRequestException":
|
|
7426
6533
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7427
|
-
|
|
7428
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7429
|
-
name: errorCode,
|
|
7430
|
-
$metadata: deserializeMetadata(output),
|
|
7431
|
-
};
|
|
7432
|
-
break;
|
|
6534
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7433
6535
|
default:
|
|
7434
6536
|
const parsedBody = parsedOutput.body;
|
|
7435
|
-
|
|
7436
|
-
|
|
7437
|
-
...parsedBody,
|
|
7438
|
-
name: `${errorCode}`,
|
|
7439
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6537
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6538
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7440
6539
|
$fault: "client",
|
|
7441
6540
|
$metadata: deserializeMetadata(output),
|
|
7442
|
-
};
|
|
6541
|
+
});
|
|
6542
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7443
6543
|
}
|
|
7444
|
-
const message = response.message || response.Message || errorCode;
|
|
7445
|
-
response.message = message;
|
|
7446
|
-
delete response.Message;
|
|
7447
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7448
6544
|
};
|
|
7449
6545
|
const deserializeAws_restJson1UpdateConnectivityInfoCommand = async (output, context) => {
|
|
7450
6546
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7476,35 +6572,19 @@ const deserializeAws_restJson1UpdateConnectivityInfoCommandError = async (output
|
|
|
7476
6572
|
switch (errorCode) {
|
|
7477
6573
|
case "BadRequestException":
|
|
7478
6574
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7479
|
-
|
|
7480
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7481
|
-
name: errorCode,
|
|
7482
|
-
$metadata: deserializeMetadata(output),
|
|
7483
|
-
};
|
|
7484
|
-
break;
|
|
6575
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7485
6576
|
case "InternalServerErrorException":
|
|
7486
6577
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
7487
|
-
|
|
7488
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
7489
|
-
name: errorCode,
|
|
7490
|
-
$metadata: deserializeMetadata(output),
|
|
7491
|
-
};
|
|
7492
|
-
break;
|
|
6578
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
7493
6579
|
default:
|
|
7494
6580
|
const parsedBody = parsedOutput.body;
|
|
7495
|
-
|
|
7496
|
-
|
|
7497
|
-
...parsedBody,
|
|
7498
|
-
name: `${errorCode}`,
|
|
7499
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6581
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6582
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7500
6583
|
$fault: "client",
|
|
7501
6584
|
$metadata: deserializeMetadata(output),
|
|
7502
|
-
};
|
|
6585
|
+
});
|
|
6586
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7503
6587
|
}
|
|
7504
|
-
const message = response.message || response.Message || errorCode;
|
|
7505
|
-
response.message = message;
|
|
7506
|
-
delete response.Message;
|
|
7507
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7508
6588
|
};
|
|
7509
6589
|
const deserializeAws_restJson1UpdateConnectorDefinitionCommand = async (output, context) => {
|
|
7510
6590
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7528,27 +6608,16 @@ const deserializeAws_restJson1UpdateConnectorDefinitionCommandError = async (out
|
|
|
7528
6608
|
switch (errorCode) {
|
|
7529
6609
|
case "BadRequestException":
|
|
7530
6610
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7531
|
-
|
|
7532
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7533
|
-
name: errorCode,
|
|
7534
|
-
$metadata: deserializeMetadata(output),
|
|
7535
|
-
};
|
|
7536
|
-
break;
|
|
6611
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7537
6612
|
default:
|
|
7538
6613
|
const parsedBody = parsedOutput.body;
|
|
7539
|
-
|
|
7540
|
-
|
|
7541
|
-
...parsedBody,
|
|
7542
|
-
name: `${errorCode}`,
|
|
7543
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6614
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6615
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7544
6616
|
$fault: "client",
|
|
7545
6617
|
$metadata: deserializeMetadata(output),
|
|
7546
|
-
};
|
|
6618
|
+
});
|
|
6619
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7547
6620
|
}
|
|
7548
|
-
const message = response.message || response.Message || errorCode;
|
|
7549
|
-
response.message = message;
|
|
7550
|
-
delete response.Message;
|
|
7551
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7552
6621
|
};
|
|
7553
6622
|
const deserializeAws_restJson1UpdateCoreDefinitionCommand = async (output, context) => {
|
|
7554
6623
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7572,27 +6641,16 @@ const deserializeAws_restJson1UpdateCoreDefinitionCommandError = async (output,
|
|
|
7572
6641
|
switch (errorCode) {
|
|
7573
6642
|
case "BadRequestException":
|
|
7574
6643
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7575
|
-
|
|
7576
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7577
|
-
name: errorCode,
|
|
7578
|
-
$metadata: deserializeMetadata(output),
|
|
7579
|
-
};
|
|
7580
|
-
break;
|
|
6644
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7581
6645
|
default:
|
|
7582
6646
|
const parsedBody = parsedOutput.body;
|
|
7583
|
-
|
|
7584
|
-
|
|
7585
|
-
...parsedBody,
|
|
7586
|
-
name: `${errorCode}`,
|
|
7587
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6647
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6648
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7588
6649
|
$fault: "client",
|
|
7589
6650
|
$metadata: deserializeMetadata(output),
|
|
7590
|
-
};
|
|
6651
|
+
});
|
|
6652
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7591
6653
|
}
|
|
7592
|
-
const message = response.message || response.Message || errorCode;
|
|
7593
|
-
response.message = message;
|
|
7594
|
-
delete response.Message;
|
|
7595
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7596
6654
|
};
|
|
7597
6655
|
const deserializeAws_restJson1UpdateDeviceDefinitionCommand = async (output, context) => {
|
|
7598
6656
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7616,27 +6674,16 @@ const deserializeAws_restJson1UpdateDeviceDefinitionCommandError = async (output
|
|
|
7616
6674
|
switch (errorCode) {
|
|
7617
6675
|
case "BadRequestException":
|
|
7618
6676
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7619
|
-
|
|
7620
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7621
|
-
name: errorCode,
|
|
7622
|
-
$metadata: deserializeMetadata(output),
|
|
7623
|
-
};
|
|
7624
|
-
break;
|
|
6677
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7625
6678
|
default:
|
|
7626
6679
|
const parsedBody = parsedOutput.body;
|
|
7627
|
-
|
|
7628
|
-
|
|
7629
|
-
...parsedBody,
|
|
7630
|
-
name: `${errorCode}`,
|
|
7631
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6680
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6681
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7632
6682
|
$fault: "client",
|
|
7633
6683
|
$metadata: deserializeMetadata(output),
|
|
7634
|
-
};
|
|
6684
|
+
});
|
|
6685
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7635
6686
|
}
|
|
7636
|
-
const message = response.message || response.Message || errorCode;
|
|
7637
|
-
response.message = message;
|
|
7638
|
-
delete response.Message;
|
|
7639
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7640
6687
|
};
|
|
7641
6688
|
const deserializeAws_restJson1UpdateFunctionDefinitionCommand = async (output, context) => {
|
|
7642
6689
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7660,27 +6707,16 @@ const deserializeAws_restJson1UpdateFunctionDefinitionCommandError = async (outp
|
|
|
7660
6707
|
switch (errorCode) {
|
|
7661
6708
|
case "BadRequestException":
|
|
7662
6709
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7663
|
-
|
|
7664
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7665
|
-
name: errorCode,
|
|
7666
|
-
$metadata: deserializeMetadata(output),
|
|
7667
|
-
};
|
|
7668
|
-
break;
|
|
6710
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7669
6711
|
default:
|
|
7670
6712
|
const parsedBody = parsedOutput.body;
|
|
7671
|
-
|
|
7672
|
-
|
|
7673
|
-
...parsedBody,
|
|
7674
|
-
name: `${errorCode}`,
|
|
7675
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6713
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6714
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7676
6715
|
$fault: "client",
|
|
7677
6716
|
$metadata: deserializeMetadata(output),
|
|
7678
|
-
};
|
|
6717
|
+
});
|
|
6718
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7679
6719
|
}
|
|
7680
|
-
const message = response.message || response.Message || errorCode;
|
|
7681
|
-
response.message = message;
|
|
7682
|
-
delete response.Message;
|
|
7683
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7684
6720
|
};
|
|
7685
6721
|
const deserializeAws_restJson1UpdateGroupCommand = async (output, context) => {
|
|
7686
6722
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7704,27 +6740,16 @@ const deserializeAws_restJson1UpdateGroupCommandError = async (output, context)
|
|
|
7704
6740
|
switch (errorCode) {
|
|
7705
6741
|
case "BadRequestException":
|
|
7706
6742
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7707
|
-
|
|
7708
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7709
|
-
name: errorCode,
|
|
7710
|
-
$metadata: deserializeMetadata(output),
|
|
7711
|
-
};
|
|
7712
|
-
break;
|
|
6743
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7713
6744
|
default:
|
|
7714
6745
|
const parsedBody = parsedOutput.body;
|
|
7715
|
-
|
|
7716
|
-
|
|
7717
|
-
...parsedBody,
|
|
7718
|
-
name: `${errorCode}`,
|
|
7719
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6746
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6747
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7720
6748
|
$fault: "client",
|
|
7721
6749
|
$metadata: deserializeMetadata(output),
|
|
7722
|
-
};
|
|
6750
|
+
});
|
|
6751
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7723
6752
|
}
|
|
7724
|
-
const message = response.message || response.Message || errorCode;
|
|
7725
|
-
response.message = message;
|
|
7726
|
-
delete response.Message;
|
|
7727
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7728
6753
|
};
|
|
7729
6754
|
const deserializeAws_restJson1UpdateGroupCertificateConfigurationCommand = async (output, context) => {
|
|
7730
6755
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7761,35 +6786,19 @@ const deserializeAws_restJson1UpdateGroupCertificateConfigurationCommandError =
|
|
|
7761
6786
|
switch (errorCode) {
|
|
7762
6787
|
case "BadRequestException":
|
|
7763
6788
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7764
|
-
|
|
7765
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7766
|
-
name: errorCode,
|
|
7767
|
-
$metadata: deserializeMetadata(output),
|
|
7768
|
-
};
|
|
7769
|
-
break;
|
|
6789
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7770
6790
|
case "InternalServerErrorException":
|
|
7771
6791
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
7772
|
-
|
|
7773
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
7774
|
-
name: errorCode,
|
|
7775
|
-
$metadata: deserializeMetadata(output),
|
|
7776
|
-
};
|
|
7777
|
-
break;
|
|
6792
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
7778
6793
|
default:
|
|
7779
6794
|
const parsedBody = parsedOutput.body;
|
|
7780
|
-
|
|
7781
|
-
|
|
7782
|
-
...parsedBody,
|
|
7783
|
-
name: `${errorCode}`,
|
|
7784
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6795
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6796
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7785
6797
|
$fault: "client",
|
|
7786
6798
|
$metadata: deserializeMetadata(output),
|
|
7787
|
-
};
|
|
6799
|
+
});
|
|
6800
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7788
6801
|
}
|
|
7789
|
-
const message = response.message || response.Message || errorCode;
|
|
7790
|
-
response.message = message;
|
|
7791
|
-
delete response.Message;
|
|
7792
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7793
6802
|
};
|
|
7794
6803
|
const deserializeAws_restJson1UpdateLoggerDefinitionCommand = async (output, context) => {
|
|
7795
6804
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7813,27 +6822,16 @@ const deserializeAws_restJson1UpdateLoggerDefinitionCommandError = async (output
|
|
|
7813
6822
|
switch (errorCode) {
|
|
7814
6823
|
case "BadRequestException":
|
|
7815
6824
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7816
|
-
|
|
7817
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7818
|
-
name: errorCode,
|
|
7819
|
-
$metadata: deserializeMetadata(output),
|
|
7820
|
-
};
|
|
7821
|
-
break;
|
|
6825
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7822
6826
|
default:
|
|
7823
6827
|
const parsedBody = parsedOutput.body;
|
|
7824
|
-
|
|
7825
|
-
|
|
7826
|
-
...parsedBody,
|
|
7827
|
-
name: `${errorCode}`,
|
|
7828
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6828
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6829
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7829
6830
|
$fault: "client",
|
|
7830
6831
|
$metadata: deserializeMetadata(output),
|
|
7831
|
-
};
|
|
6832
|
+
});
|
|
6833
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7832
6834
|
}
|
|
7833
|
-
const message = response.message || response.Message || errorCode;
|
|
7834
|
-
response.message = message;
|
|
7835
|
-
delete response.Message;
|
|
7836
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7837
6835
|
};
|
|
7838
6836
|
const deserializeAws_restJson1UpdateResourceDefinitionCommand = async (output, context) => {
|
|
7839
6837
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7857,27 +6855,16 @@ const deserializeAws_restJson1UpdateResourceDefinitionCommandError = async (outp
|
|
|
7857
6855
|
switch (errorCode) {
|
|
7858
6856
|
case "BadRequestException":
|
|
7859
6857
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7860
|
-
|
|
7861
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7862
|
-
name: errorCode,
|
|
7863
|
-
$metadata: deserializeMetadata(output),
|
|
7864
|
-
};
|
|
7865
|
-
break;
|
|
6858
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7866
6859
|
default:
|
|
7867
6860
|
const parsedBody = parsedOutput.body;
|
|
7868
|
-
|
|
7869
|
-
|
|
7870
|
-
...parsedBody,
|
|
7871
|
-
name: `${errorCode}`,
|
|
7872
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6861
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6862
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7873
6863
|
$fault: "client",
|
|
7874
6864
|
$metadata: deserializeMetadata(output),
|
|
7875
|
-
};
|
|
6865
|
+
});
|
|
6866
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7876
6867
|
}
|
|
7877
|
-
const message = response.message || response.Message || errorCode;
|
|
7878
|
-
response.message = message;
|
|
7879
|
-
delete response.Message;
|
|
7880
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7881
6868
|
};
|
|
7882
6869
|
const deserializeAws_restJson1UpdateSubscriptionDefinitionCommand = async (output, context) => {
|
|
7883
6870
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7901,27 +6888,16 @@ const deserializeAws_restJson1UpdateSubscriptionDefinitionCommandError = async (
|
|
|
7901
6888
|
switch (errorCode) {
|
|
7902
6889
|
case "BadRequestException":
|
|
7903
6890
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7904
|
-
|
|
7905
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7906
|
-
name: errorCode,
|
|
7907
|
-
$metadata: deserializeMetadata(output),
|
|
7908
|
-
};
|
|
7909
|
-
break;
|
|
6891
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7910
6892
|
default:
|
|
7911
6893
|
const parsedBody = parsedOutput.body;
|
|
7912
|
-
|
|
7913
|
-
|
|
7914
|
-
...parsedBody,
|
|
7915
|
-
name: `${errorCode}`,
|
|
7916
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6894
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6895
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7917
6896
|
$fault: "client",
|
|
7918
6897
|
$metadata: deserializeMetadata(output),
|
|
7919
|
-
};
|
|
6898
|
+
});
|
|
6899
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7920
6900
|
}
|
|
7921
|
-
const message = response.message || response.Message || errorCode;
|
|
7922
|
-
response.message = message;
|
|
7923
|
-
delete response.Message;
|
|
7924
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7925
6901
|
};
|
|
7926
6902
|
const deserializeAws_restJson1UpdateThingRuntimeConfigurationCommand = async (output, context) => {
|
|
7927
6903
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -7945,44 +6921,22 @@ const deserializeAws_restJson1UpdateThingRuntimeConfigurationCommandError = asyn
|
|
|
7945
6921
|
switch (errorCode) {
|
|
7946
6922
|
case "BadRequestException":
|
|
7947
6923
|
case "com.amazonaws.greengrass#BadRequestException":
|
|
7948
|
-
|
|
7949
|
-
...(await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)),
|
|
7950
|
-
name: errorCode,
|
|
7951
|
-
$metadata: deserializeMetadata(output),
|
|
7952
|
-
};
|
|
7953
|
-
break;
|
|
6924
|
+
throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
|
|
7954
6925
|
case "InternalServerErrorException":
|
|
7955
6926
|
case "com.amazonaws.greengrass#InternalServerErrorException":
|
|
7956
|
-
|
|
7957
|
-
...(await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context)),
|
|
7958
|
-
name: errorCode,
|
|
7959
|
-
$metadata: deserializeMetadata(output),
|
|
7960
|
-
};
|
|
7961
|
-
break;
|
|
6927
|
+
throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
|
|
7962
6928
|
default:
|
|
7963
6929
|
const parsedBody = parsedOutput.body;
|
|
7964
|
-
|
|
7965
|
-
|
|
7966
|
-
...parsedBody,
|
|
7967
|
-
name: `${errorCode}`,
|
|
7968
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
6930
|
+
response = new GreengrassServiceException_1.GreengrassServiceException({
|
|
6931
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
7969
6932
|
$fault: "client",
|
|
7970
6933
|
$metadata: deserializeMetadata(output),
|
|
7971
|
-
};
|
|
6934
|
+
});
|
|
6935
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
7972
6936
|
}
|
|
7973
|
-
const message = response.message || response.Message || errorCode;
|
|
7974
|
-
response.message = message;
|
|
7975
|
-
delete response.Message;
|
|
7976
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
7977
6937
|
};
|
|
7978
6938
|
const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
|
|
7979
|
-
const contents = {
|
|
7980
|
-
name: "BadRequestException",
|
|
7981
|
-
$fault: "client",
|
|
7982
|
-
$metadata: deserializeMetadata(parsedOutput),
|
|
7983
|
-
ErrorDetails: undefined,
|
|
7984
|
-
Message: undefined,
|
|
7985
|
-
};
|
|
6939
|
+
const contents = {};
|
|
7986
6940
|
const data = parsedOutput.body;
|
|
7987
6941
|
if (data.ErrorDetails !== undefined && data.ErrorDetails !== null) {
|
|
7988
6942
|
contents.ErrorDetails = deserializeAws_restJson1ErrorDetails(data.ErrorDetails, context);
|
|
@@ -7990,16 +6944,14 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
|
|
|
7990
6944
|
if (data.Message !== undefined && data.Message !== null) {
|
|
7991
6945
|
contents.Message = smithy_client_1.expectString(data.Message);
|
|
7992
6946
|
}
|
|
7993
|
-
|
|
6947
|
+
const exception = new models_0_1.BadRequestException({
|
|
6948
|
+
$metadata: deserializeMetadata(parsedOutput),
|
|
6949
|
+
...contents,
|
|
6950
|
+
});
|
|
6951
|
+
return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
|
|
7994
6952
|
};
|
|
7995
6953
|
const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
|
|
7996
|
-
const contents = {
|
|
7997
|
-
name: "InternalServerErrorException",
|
|
7998
|
-
$fault: "server",
|
|
7999
|
-
$metadata: deserializeMetadata(parsedOutput),
|
|
8000
|
-
ErrorDetails: undefined,
|
|
8001
|
-
Message: undefined,
|
|
8002
|
-
};
|
|
6954
|
+
const contents = {};
|
|
8003
6955
|
const data = parsedOutput.body;
|
|
8004
6956
|
if (data.ErrorDetails !== undefined && data.ErrorDetails !== null) {
|
|
8005
6957
|
contents.ErrorDetails = deserializeAws_restJson1ErrorDetails(data.ErrorDetails, context);
|
|
@@ -8007,7 +6959,11 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
|
|
|
8007
6959
|
if (data.Message !== undefined && data.Message !== null) {
|
|
8008
6960
|
contents.Message = smithy_client_1.expectString(data.Message);
|
|
8009
6961
|
}
|
|
8010
|
-
|
|
6962
|
+
const exception = new models_0_1.InternalServerErrorException({
|
|
6963
|
+
$metadata: deserializeMetadata(parsedOutput),
|
|
6964
|
+
...contents,
|
|
6965
|
+
});
|
|
6966
|
+
return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
|
|
8011
6967
|
};
|
|
8012
6968
|
const serializeAws_restJson1__listOf__string = (input, context) => {
|
|
8013
6969
|
return input
|
|
@@ -8445,7 +7401,7 @@ const serializeAws_restJson1UpdateTargets = (input, context) => {
|
|
|
8445
7401
|
});
|
|
8446
7402
|
};
|
|
8447
7403
|
const deserializeAws_restJson1__listOf__string = (output, context) => {
|
|
8448
|
-
|
|
7404
|
+
const retVal = (output || [])
|
|
8449
7405
|
.filter((e) => e != null)
|
|
8450
7406
|
.map((entry) => {
|
|
8451
7407
|
if (entry === null) {
|
|
@@ -8453,9 +7409,10 @@ const deserializeAws_restJson1__listOf__string = (output, context) => {
|
|
|
8453
7409
|
}
|
|
8454
7410
|
return smithy_client_1.expectString(entry);
|
|
8455
7411
|
});
|
|
7412
|
+
return retVal;
|
|
8456
7413
|
};
|
|
8457
7414
|
const deserializeAws_restJson1__listOfConnectivityInfo = (output, context) => {
|
|
8458
|
-
|
|
7415
|
+
const retVal = (output || [])
|
|
8459
7416
|
.filter((e) => e != null)
|
|
8460
7417
|
.map((entry) => {
|
|
8461
7418
|
if (entry === null) {
|
|
@@ -8463,9 +7420,10 @@ const deserializeAws_restJson1__listOfConnectivityInfo = (output, context) => {
|
|
|
8463
7420
|
}
|
|
8464
7421
|
return deserializeAws_restJson1ConnectivityInfo(entry, context);
|
|
8465
7422
|
});
|
|
7423
|
+
return retVal;
|
|
8466
7424
|
};
|
|
8467
7425
|
const deserializeAws_restJson1__listOfConnector = (output, context) => {
|
|
8468
|
-
|
|
7426
|
+
const retVal = (output || [])
|
|
8469
7427
|
.filter((e) => e != null)
|
|
8470
7428
|
.map((entry) => {
|
|
8471
7429
|
if (entry === null) {
|
|
@@ -8473,9 +7431,10 @@ const deserializeAws_restJson1__listOfConnector = (output, context) => {
|
|
|
8473
7431
|
}
|
|
8474
7432
|
return deserializeAws_restJson1Connector(entry, context);
|
|
8475
7433
|
});
|
|
7434
|
+
return retVal;
|
|
8476
7435
|
};
|
|
8477
7436
|
const deserializeAws_restJson1__listOfCore = (output, context) => {
|
|
8478
|
-
|
|
7437
|
+
const retVal = (output || [])
|
|
8479
7438
|
.filter((e) => e != null)
|
|
8480
7439
|
.map((entry) => {
|
|
8481
7440
|
if (entry === null) {
|
|
@@ -8483,9 +7442,10 @@ const deserializeAws_restJson1__listOfCore = (output, context) => {
|
|
|
8483
7442
|
}
|
|
8484
7443
|
return deserializeAws_restJson1Core(entry, context);
|
|
8485
7444
|
});
|
|
7445
|
+
return retVal;
|
|
8486
7446
|
};
|
|
8487
7447
|
const deserializeAws_restJson1__listOfDefinitionInformation = (output, context) => {
|
|
8488
|
-
|
|
7448
|
+
const retVal = (output || [])
|
|
8489
7449
|
.filter((e) => e != null)
|
|
8490
7450
|
.map((entry) => {
|
|
8491
7451
|
if (entry === null) {
|
|
@@ -8493,9 +7453,10 @@ const deserializeAws_restJson1__listOfDefinitionInformation = (output, context)
|
|
|
8493
7453
|
}
|
|
8494
7454
|
return deserializeAws_restJson1DefinitionInformation(entry, context);
|
|
8495
7455
|
});
|
|
7456
|
+
return retVal;
|
|
8496
7457
|
};
|
|
8497
7458
|
const deserializeAws_restJson1__listOfDevice = (output, context) => {
|
|
8498
|
-
|
|
7459
|
+
const retVal = (output || [])
|
|
8499
7460
|
.filter((e) => e != null)
|
|
8500
7461
|
.map((entry) => {
|
|
8501
7462
|
if (entry === null) {
|
|
@@ -8503,9 +7464,10 @@ const deserializeAws_restJson1__listOfDevice = (output, context) => {
|
|
|
8503
7464
|
}
|
|
8504
7465
|
return deserializeAws_restJson1Device(entry, context);
|
|
8505
7466
|
});
|
|
7467
|
+
return retVal;
|
|
8506
7468
|
};
|
|
8507
7469
|
const deserializeAws_restJson1__listOfFunction = (output, context) => {
|
|
8508
|
-
|
|
7470
|
+
const retVal = (output || [])
|
|
8509
7471
|
.filter((e) => e != null)
|
|
8510
7472
|
.map((entry) => {
|
|
8511
7473
|
if (entry === null) {
|
|
@@ -8513,9 +7475,10 @@ const deserializeAws_restJson1__listOfFunction = (output, context) => {
|
|
|
8513
7475
|
}
|
|
8514
7476
|
return deserializeAws_restJson1Function(entry, context);
|
|
8515
7477
|
});
|
|
7478
|
+
return retVal;
|
|
8516
7479
|
};
|
|
8517
7480
|
const deserializeAws_restJson1__listOfGroupCertificateAuthorityProperties = (output, context) => {
|
|
8518
|
-
|
|
7481
|
+
const retVal = (output || [])
|
|
8519
7482
|
.filter((e) => e != null)
|
|
8520
7483
|
.map((entry) => {
|
|
8521
7484
|
if (entry === null) {
|
|
@@ -8523,9 +7486,10 @@ const deserializeAws_restJson1__listOfGroupCertificateAuthorityProperties = (out
|
|
|
8523
7486
|
}
|
|
8524
7487
|
return deserializeAws_restJson1GroupCertificateAuthorityProperties(entry, context);
|
|
8525
7488
|
});
|
|
7489
|
+
return retVal;
|
|
8526
7490
|
};
|
|
8527
7491
|
const deserializeAws_restJson1__listOfGroupInformation = (output, context) => {
|
|
8528
|
-
|
|
7492
|
+
const retVal = (output || [])
|
|
8529
7493
|
.filter((e) => e != null)
|
|
8530
7494
|
.map((entry) => {
|
|
8531
7495
|
if (entry === null) {
|
|
@@ -8533,9 +7497,10 @@ const deserializeAws_restJson1__listOfGroupInformation = (output, context) => {
|
|
|
8533
7497
|
}
|
|
8534
7498
|
return deserializeAws_restJson1GroupInformation(entry, context);
|
|
8535
7499
|
});
|
|
7500
|
+
return retVal;
|
|
8536
7501
|
};
|
|
8537
7502
|
const deserializeAws_restJson1__listOfLogger = (output, context) => {
|
|
8538
|
-
|
|
7503
|
+
const retVal = (output || [])
|
|
8539
7504
|
.filter((e) => e != null)
|
|
8540
7505
|
.map((entry) => {
|
|
8541
7506
|
if (entry === null) {
|
|
@@ -8543,9 +7508,10 @@ const deserializeAws_restJson1__listOfLogger = (output, context) => {
|
|
|
8543
7508
|
}
|
|
8544
7509
|
return deserializeAws_restJson1Logger(entry, context);
|
|
8545
7510
|
});
|
|
7511
|
+
return retVal;
|
|
8546
7512
|
};
|
|
8547
7513
|
const deserializeAws_restJson1__listOfResource = (output, context) => {
|
|
8548
|
-
|
|
7514
|
+
const retVal = (output || [])
|
|
8549
7515
|
.filter((e) => e != null)
|
|
8550
7516
|
.map((entry) => {
|
|
8551
7517
|
if (entry === null) {
|
|
@@ -8553,9 +7519,10 @@ const deserializeAws_restJson1__listOfResource = (output, context) => {
|
|
|
8553
7519
|
}
|
|
8554
7520
|
return deserializeAws_restJson1Resource(entry, context);
|
|
8555
7521
|
});
|
|
7522
|
+
return retVal;
|
|
8556
7523
|
};
|
|
8557
7524
|
const deserializeAws_restJson1__listOfResourceAccessPolicy = (output, context) => {
|
|
8558
|
-
|
|
7525
|
+
const retVal = (output || [])
|
|
8559
7526
|
.filter((e) => e != null)
|
|
8560
7527
|
.map((entry) => {
|
|
8561
7528
|
if (entry === null) {
|
|
@@ -8563,9 +7530,10 @@ const deserializeAws_restJson1__listOfResourceAccessPolicy = (output, context) =
|
|
|
8563
7530
|
}
|
|
8564
7531
|
return deserializeAws_restJson1ResourceAccessPolicy(entry, context);
|
|
8565
7532
|
});
|
|
7533
|
+
return retVal;
|
|
8566
7534
|
};
|
|
8567
7535
|
const deserializeAws_restJson1__listOfSubscription = (output, context) => {
|
|
8568
|
-
|
|
7536
|
+
const retVal = (output || [])
|
|
8569
7537
|
.filter((e) => e != null)
|
|
8570
7538
|
.map((entry) => {
|
|
8571
7539
|
if (entry === null) {
|
|
@@ -8573,9 +7541,10 @@ const deserializeAws_restJson1__listOfSubscription = (output, context) => {
|
|
|
8573
7541
|
}
|
|
8574
7542
|
return deserializeAws_restJson1Subscription(entry, context);
|
|
8575
7543
|
});
|
|
7544
|
+
return retVal;
|
|
8576
7545
|
};
|
|
8577
7546
|
const deserializeAws_restJson1__listOfVersionInformation = (output, context) => {
|
|
8578
|
-
|
|
7547
|
+
const retVal = (output || [])
|
|
8579
7548
|
.filter((e) => e != null)
|
|
8580
7549
|
.map((entry) => {
|
|
8581
7550
|
if (entry === null) {
|
|
@@ -8583,6 +7552,7 @@ const deserializeAws_restJson1__listOfVersionInformation = (output, context) =>
|
|
|
8583
7552
|
}
|
|
8584
7553
|
return deserializeAws_restJson1VersionInformation(entry, context);
|
|
8585
7554
|
});
|
|
7555
|
+
return retVal;
|
|
8586
7556
|
};
|
|
8587
7557
|
const deserializeAws_restJson1__mapOf__string = (output, context) => {
|
|
8588
7558
|
return Object.entries(output).reduce((acc, [key, value]) => {
|
|
@@ -8624,7 +7594,7 @@ const deserializeAws_restJson1BulkDeploymentResult = (output, context) => {
|
|
|
8624
7594
|
};
|
|
8625
7595
|
};
|
|
8626
7596
|
const deserializeAws_restJson1BulkDeploymentResults = (output, context) => {
|
|
8627
|
-
|
|
7597
|
+
const retVal = (output || [])
|
|
8628
7598
|
.filter((e) => e != null)
|
|
8629
7599
|
.map((entry) => {
|
|
8630
7600
|
if (entry === null) {
|
|
@@ -8632,9 +7602,10 @@ const deserializeAws_restJson1BulkDeploymentResults = (output, context) => {
|
|
|
8632
7602
|
}
|
|
8633
7603
|
return deserializeAws_restJson1BulkDeploymentResult(entry, context);
|
|
8634
7604
|
});
|
|
7605
|
+
return retVal;
|
|
8635
7606
|
};
|
|
8636
7607
|
const deserializeAws_restJson1BulkDeployments = (output, context) => {
|
|
8637
|
-
|
|
7608
|
+
const retVal = (output || [])
|
|
8638
7609
|
.filter((e) => e != null)
|
|
8639
7610
|
.map((entry) => {
|
|
8640
7611
|
if (entry === null) {
|
|
@@ -8642,6 +7613,7 @@ const deserializeAws_restJson1BulkDeployments = (output, context) => {
|
|
|
8642
7613
|
}
|
|
8643
7614
|
return deserializeAws_restJson1BulkDeployment(entry, context);
|
|
8644
7615
|
});
|
|
7616
|
+
return retVal;
|
|
8645
7617
|
};
|
|
8646
7618
|
const deserializeAws_restJson1ConnectivityInfo = (output, context) => {
|
|
8647
7619
|
return {
|
|
@@ -8706,7 +7678,7 @@ const deserializeAws_restJson1Deployment = (output, context) => {
|
|
|
8706
7678
|
};
|
|
8707
7679
|
};
|
|
8708
7680
|
const deserializeAws_restJson1Deployments = (output, context) => {
|
|
8709
|
-
|
|
7681
|
+
const retVal = (output || [])
|
|
8710
7682
|
.filter((e) => e != null)
|
|
8711
7683
|
.map((entry) => {
|
|
8712
7684
|
if (entry === null) {
|
|
@@ -8714,6 +7686,7 @@ const deserializeAws_restJson1Deployments = (output, context) => {
|
|
|
8714
7686
|
}
|
|
8715
7687
|
return deserializeAws_restJson1Deployment(entry, context);
|
|
8716
7688
|
});
|
|
7689
|
+
return retVal;
|
|
8717
7690
|
};
|
|
8718
7691
|
const deserializeAws_restJson1Device = (output, context) => {
|
|
8719
7692
|
return {
|
|
@@ -8737,7 +7710,7 @@ const deserializeAws_restJson1ErrorDetail = (output, context) => {
|
|
|
8737
7710
|
};
|
|
8738
7711
|
};
|
|
8739
7712
|
const deserializeAws_restJson1ErrorDetails = (output, context) => {
|
|
8740
|
-
|
|
7713
|
+
const retVal = (output || [])
|
|
8741
7714
|
.filter((e) => e != null)
|
|
8742
7715
|
.map((entry) => {
|
|
8743
7716
|
if (entry === null) {
|
|
@@ -8745,6 +7718,7 @@ const deserializeAws_restJson1ErrorDetails = (output, context) => {
|
|
|
8745
7718
|
}
|
|
8746
7719
|
return deserializeAws_restJson1ErrorDetail(entry, context);
|
|
8747
7720
|
});
|
|
7721
|
+
return retVal;
|
|
8748
7722
|
};
|
|
8749
7723
|
const deserializeAws_restJson1Function = (output, context) => {
|
|
8750
7724
|
return {
|