@aws-sdk/client-ec2-instance-connect 3.306.0 → 3.309.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist-cjs/commands/SendSSHPublicKeyCommand.js +2 -2
  2. package/dist-cjs/commands/SendSerialConsoleSSHPublicKeyCommand.js +2 -2
  3. package/dist-cjs/protocols/Aws_json1_1.js +72 -72
  4. package/dist-es/commands/SendSSHPublicKeyCommand.js +3 -3
  5. package/dist-es/commands/SendSerialConsoleSSHPublicKeyCommand.js +3 -3
  6. package/dist-es/protocols/Aws_json1_1.js +67 -67
  7. package/dist-types/protocols/Aws_json1_1.d.ts +16 -4
  8. package/dist-types/ts3.4/protocols/Aws_json1_1.d.ts +4 -4
  9. package/package.json +6 -6
package/dist-cjs/commands/SendSSHPublicKeyCommand.js CHANGED
@@ -36,10 +36,10 @@ class SendSSHPublicKeyCommand extends smithy_client_1.Command {
36
36
  return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
37
37
  }
38
38
  serialize(input, context) {
39
- return (0, Aws_json1_1_1.serializeAws_json1_1SendSSHPublicKeyCommand)(input, context);
39
+ return (0, Aws_json1_1_1.se_SendSSHPublicKeyCommand)(input, context);
40
40
  }
41
41
  deserialize(output, context) {
42
- return (0, Aws_json1_1_1.deserializeAws_json1_1SendSSHPublicKeyCommand)(output, context);
42
+ return (0, Aws_json1_1_1.de_SendSSHPublicKeyCommand)(output, context);
43
43
  }
44
44
  }
45
45
  exports.SendSSHPublicKeyCommand = SendSSHPublicKeyCommand;
package/dist-cjs/commands/SendSerialConsoleSSHPublicKeyCommand.js CHANGED
@@ -36,10 +36,10 @@ class SendSerialConsoleSSHPublicKeyCommand extends smithy_client_1.Command {
36
36
  return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
37
37
  }
38
38
  serialize(input, context) {
39
- return (0, Aws_json1_1_1.serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand)(input, context);
39
+ return (0, Aws_json1_1_1.se_SendSerialConsoleSSHPublicKeyCommand)(input, context);
40
40
  }
41
41
  deserialize(output, context) {
42
- return (0, Aws_json1_1_1.deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand)(output, context);
42
+ return (0, Aws_json1_1_1.de_SendSerialConsoleSSHPublicKeyCommand)(output, context);
43
43
  }
44
44
  }
45
45
  exports.SendSerialConsoleSSHPublicKeyCommand = SendSerialConsoleSSHPublicKeyCommand;
package/dist-cjs/protocols/Aws_json1_1.js CHANGED
@@ -1,45 +1,45 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.deserializeAws_json1_1SendSSHPublicKeyCommand = exports.deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = exports.serializeAws_json1_1SendSSHPublicKeyCommand = exports.serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = void 0;
3
+ exports.de_SendSSHPublicKeyCommand = exports.de_SendSerialConsoleSSHPublicKeyCommand = exports.se_SendSSHPublicKeyCommand = exports.se_SendSerialConsoleSSHPublicKeyCommand = void 0;
4
4
  const protocol_http_1 = require("@aws-sdk/protocol-http");
5
5
  const smithy_client_1 = require("@aws-sdk/smithy-client");
6
6
  const EC2InstanceConnectServiceException_1 = require("../models/EC2InstanceConnectServiceException");
7
7
  const models_0_1 = require("../models/models_0");
8
- const serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = async (input, context) => {
8
+ const se_SendSerialConsoleSSHPublicKeyCommand = async (input, context) => {
9
9
  const headers = {
10
10
  "content-type": "application/x-amz-json-1.1",
11
11
  "x-amz-target": "AWSEC2InstanceConnectService.SendSerialConsoleSSHPublicKey",
12
12
  };
13
13
  let body;
14
- body = JSON.stringify(serializeAws_json1_1SendSerialConsoleSSHPublicKeyRequest(input, context));
14
+ body = JSON.stringify(se_SendSerialConsoleSSHPublicKeyRequest(input, context));
15
15
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
16
16
  };
17
- exports.serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand;
18
- const serializeAws_json1_1SendSSHPublicKeyCommand = async (input, context) => {
17
+ exports.se_SendSerialConsoleSSHPublicKeyCommand = se_SendSerialConsoleSSHPublicKeyCommand;
18
+ const se_SendSSHPublicKeyCommand = async (input, context) => {
19
19
  const headers = {
20
20
  "content-type": "application/x-amz-json-1.1",
21
21
  "x-amz-target": "AWSEC2InstanceConnectService.SendSSHPublicKey",
22
22
  };
23
23
  let body;
24
- body = JSON.stringify(serializeAws_json1_1SendSSHPublicKeyRequest(input, context));
24
+ body = JSON.stringify(se_SendSSHPublicKeyRequest(input, context));
25
25
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
26
26
  };
27
- exports.serializeAws_json1_1SendSSHPublicKeyCommand = serializeAws_json1_1SendSSHPublicKeyCommand;
28
- const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = async (output, context) => {
27
+ exports.se_SendSSHPublicKeyCommand = se_SendSSHPublicKeyCommand;
28
+ const de_SendSerialConsoleSSHPublicKeyCommand = async (output, context) => {
29
29
  if (output.statusCode >= 300) {
30
- return deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError(output, context);
30
+ return de_SendSerialConsoleSSHPublicKeyCommandError(output, context);
31
31
  }
32
32
  const data = await parseBody(output.body, context);
33
33
  let contents = {};
34
- contents = deserializeAws_json1_1SendSerialConsoleSSHPublicKeyResponse(data, context);
34
+ contents = de_SendSerialConsoleSSHPublicKeyResponse(data, context);
35
35
  const response = {
36
36
  $metadata: deserializeMetadata(output),
37
37
  ...contents,
38
38
  };
39
39
  return Promise.resolve(response);
40
40
  };
41
- exports.deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand;
42
- const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (output, context) => {
41
+ exports.de_SendSerialConsoleSSHPublicKeyCommand = de_SendSerialConsoleSSHPublicKeyCommand;
42
+ const de_SendSerialConsoleSSHPublicKeyCommandError = async (output, context) => {
43
43
  const parsedOutput = {
44
44
  ...output,
45
45
  body: await parseErrorBody(output.body, context),
@@ -48,37 +48,37 @@ const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (o
48
48
  switch (errorCode) {
49
49
  case "AuthException":
50
50
  case "com.amazonaws.ec2instanceconnect#AuthException":
51
- throw await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context);
51
+ throw await de_AuthExceptionRes(parsedOutput, context);
52
52
  case "EC2InstanceNotFoundException":
53
53
  case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
54
- throw await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context);
54
+ throw await de_EC2InstanceNotFoundExceptionRes(parsedOutput, context);
55
55
  case "EC2InstanceStateInvalidException":
56
56
  case "com.amazonaws.ec2instanceconnect#EC2InstanceStateInvalidException":
57
- throw await deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse(parsedOutput, context);
57
+ throw await de_EC2InstanceStateInvalidExceptionRes(parsedOutput, context);
58
58
  case "EC2InstanceTypeInvalidException":
59
59
  case "com.amazonaws.ec2instanceconnect#EC2InstanceTypeInvalidException":
60
- throw await deserializeAws_json1_1EC2InstanceTypeInvalidExceptionResponse(parsedOutput, context);
60
+ throw await de_EC2InstanceTypeInvalidExceptionRes(parsedOutput, context);
61
61
  case "EC2InstanceUnavailableException":
62
62
  case "com.amazonaws.ec2instanceconnect#EC2InstanceUnavailableException":
63
- throw await deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse(parsedOutput, context);
63
+ throw await de_EC2InstanceUnavailableExceptionRes(parsedOutput, context);
64
64
  case "InvalidArgsException":
65
65
  case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
66
- throw await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context);
66
+ throw await de_InvalidArgsExceptionRes(parsedOutput, context);
67
67
  case "SerialConsoleAccessDisabledException":
68
68
  case "com.amazonaws.ec2instanceconnect#SerialConsoleAccessDisabledException":
69
- throw await deserializeAws_json1_1SerialConsoleAccessDisabledExceptionResponse(parsedOutput, context);
69
+ throw await de_SerialConsoleAccessDisabledExceptionRes(parsedOutput, context);
70
70
  case "SerialConsoleSessionLimitExceededException":
71
71
  case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionLimitExceededException":
72
- throw await deserializeAws_json1_1SerialConsoleSessionLimitExceededExceptionResponse(parsedOutput, context);
72
+ throw await de_SerialConsoleSessionLimitExceededExceptionRes(parsedOutput, context);
73
73
  case "SerialConsoleSessionUnavailableException":
74
74
  case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionUnavailableException":
75
- throw await deserializeAws_json1_1SerialConsoleSessionUnavailableExceptionResponse(parsedOutput, context);
75
+ throw await de_SerialConsoleSessionUnavailableExceptionRes(parsedOutput, context);
76
76
  case "ServiceException":
77
77
  case "com.amazonaws.ec2instanceconnect#ServiceException":
78
- throw await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context);
78
+ throw await de_ServiceExceptionRes(parsedOutput, context);
79
79
  case "ThrottlingException":
80
80
  case "com.amazonaws.ec2instanceconnect#ThrottlingException":
81
- throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
81
+ throw await de_ThrottlingExceptionRes(parsedOutput, context);
82
82
  default:
83
83
  const parsedBody = parsedOutput.body;
84
84
  (0, smithy_client_1.throwDefaultError)({
@@ -89,21 +89,21 @@ const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (o
89
89
  });
90
90
  }
91
91
  };
92
- const deserializeAws_json1_1SendSSHPublicKeyCommand = async (output, context) => {
92
+ const de_SendSSHPublicKeyCommand = async (output, context) => {
93
93
  if (output.statusCode >= 300) {
94
- return deserializeAws_json1_1SendSSHPublicKeyCommandError(output, context);
94
+ return de_SendSSHPublicKeyCommandError(output, context);
95
95
  }
96
96
  const data = await parseBody(output.body, context);
97
97
  let contents = {};
98
- contents = deserializeAws_json1_1SendSSHPublicKeyResponse(data, context);
98
+ contents = de_SendSSHPublicKeyResponse(data, context);
99
99
  const response = {
100
100
  $metadata: deserializeMetadata(output),
101
101
  ...contents,
102
102
  };
103
103
  return Promise.resolve(response);
104
104
  };
105
- exports.deserializeAws_json1_1SendSSHPublicKeyCommand = deserializeAws_json1_1SendSSHPublicKeyCommand;
106
- const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, context) => {
105
+ exports.de_SendSSHPublicKeyCommand = de_SendSSHPublicKeyCommand;
106
+ const de_SendSSHPublicKeyCommandError = async (output, context) => {
107
107
  const parsedOutput = {
108
108
  ...output,
109
109
  body: await parseErrorBody(output.body, context),
@@ -112,25 +112,25 @@ const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, contex
112
112
  switch (errorCode) {
113
113
  case "AuthException":
114
114
  case "com.amazonaws.ec2instanceconnect#AuthException":
115
- throw await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context);
115
+ throw await de_AuthExceptionRes(parsedOutput, context);
116
116
  case "EC2InstanceNotFoundException":
117
117
  case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
118
- throw await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context);
118
+ throw await de_EC2InstanceNotFoundExceptionRes(parsedOutput, context);
119
119
  case "EC2InstanceStateInvalidException":
120
120
  case "com.amazonaws.ec2instanceconnect#EC2InstanceStateInvalidException":
121
- throw await deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse(parsedOutput, context);
121
+ throw await de_EC2InstanceStateInvalidExceptionRes(parsedOutput, context);
122
122
  case "EC2InstanceUnavailableException":
123
123
  case "com.amazonaws.ec2instanceconnect#EC2InstanceUnavailableException":
124
- throw await deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse(parsedOutput, context);
124
+ throw await de_EC2InstanceUnavailableExceptionRes(parsedOutput, context);
125
125
  case "InvalidArgsException":
126
126
  case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
127
- throw await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context);
127
+ throw await de_InvalidArgsExceptionRes(parsedOutput, context);
128
128
  case "ServiceException":
129
129
  case "com.amazonaws.ec2instanceconnect#ServiceException":
130
- throw await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context);
130
+ throw await de_ServiceExceptionRes(parsedOutput, context);
131
131
  case "ThrottlingException":
132
132
  case "com.amazonaws.ec2instanceconnect#ThrottlingException":
133
- throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
133
+ throw await de_ThrottlingExceptionRes(parsedOutput, context);
134
134
  default:
135
135
  const parsedBody = parsedOutput.body;
136
136
  (0, smithy_client_1.throwDefaultError)({
@@ -141,113 +141,113 @@ const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, contex
141
141
  });
142
142
  }
143
143
  };
144
- const deserializeAws_json1_1AuthExceptionResponse = async (parsedOutput, context) => {
144
+ const de_AuthExceptionRes = async (parsedOutput, context) => {
145
145
  const body = parsedOutput.body;
146
- const deserialized = deserializeAws_json1_1AuthException(body, context);
146
+ const deserialized = de_AuthException(body, context);
147
147
  const exception = new models_0_1.AuthException({
148
148
  $metadata: deserializeMetadata(parsedOutput),
149
149
  ...deserialized,
150
150
  });
151
151
  return (0, smithy_client_1.decorateServiceException)(exception, body);
152
152
  };
153
- const deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse = async (parsedOutput, context) => {
153
+ const de_EC2InstanceNotFoundExceptionRes = async (parsedOutput, context) => {
154
154
  const body = parsedOutput.body;
155
- const deserialized = deserializeAws_json1_1EC2InstanceNotFoundException(body, context);
155
+ const deserialized = de_EC2InstanceNotFoundException(body, context);
156
156
  const exception = new models_0_1.EC2InstanceNotFoundException({
157
157
  $metadata: deserializeMetadata(parsedOutput),
158
158
  ...deserialized,
159
159
  });
160
160
  return (0, smithy_client_1.decorateServiceException)(exception, body);
161
161
  };
162
- const deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse = async (parsedOutput, context) => {
162
+ const de_EC2InstanceStateInvalidExceptionRes = async (parsedOutput, context) => {
163
163
  const body = parsedOutput.body;
164
- const deserialized = deserializeAws_json1_1EC2InstanceStateInvalidException(body, context);
164
+ const deserialized = de_EC2InstanceStateInvalidException(body, context);
165
165
  const exception = new models_0_1.EC2InstanceStateInvalidException({
166
166
  $metadata: deserializeMetadata(parsedOutput),
167
167
  ...deserialized,
168
168
  });
169
169
  return (0, smithy_client_1.decorateServiceException)(exception, body);
170
170
  };
171
- const deserializeAws_json1_1EC2InstanceTypeInvalidExceptionResponse = async (parsedOutput, context) => {
171
+ const de_EC2InstanceTypeInvalidExceptionRes = async (parsedOutput, context) => {
172
172
  const body = parsedOutput.body;
173
- const deserialized = deserializeAws_json1_1EC2InstanceTypeInvalidException(body, context);
173
+ const deserialized = de_EC2InstanceTypeInvalidException(body, context);
174
174
  const exception = new models_0_1.EC2InstanceTypeInvalidException({
175
175
  $metadata: deserializeMetadata(parsedOutput),
176
176
  ...deserialized,
177
177
  });
178
178
  return (0, smithy_client_1.decorateServiceException)(exception, body);
179
179
  };
180
- const deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse = async (parsedOutput, context) => {
180
+ const de_EC2InstanceUnavailableExceptionRes = async (parsedOutput, context) => {
181
181
  const body = parsedOutput.body;
182
- const deserialized = deserializeAws_json1_1EC2InstanceUnavailableException(body, context);
182
+ const deserialized = de_EC2InstanceUnavailableException(body, context);
183
183
  const exception = new models_0_1.EC2InstanceUnavailableException({
184
184
  $metadata: deserializeMetadata(parsedOutput),
185
185
  ...deserialized,
186
186
  });
187
187
  return (0, smithy_client_1.decorateServiceException)(exception, body);
188
188
  };
189
- const deserializeAws_json1_1InvalidArgsExceptionResponse = async (parsedOutput, context) => {
189
+ const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
190
190
  const body = parsedOutput.body;
191
- const deserialized = deserializeAws_json1_1InvalidArgsException(body, context);
191
+ const deserialized = de_InvalidArgsException(body, context);
192
192
  const exception = new models_0_1.InvalidArgsException({
193
193
  $metadata: deserializeMetadata(parsedOutput),
194
194
  ...deserialized,
195
195
  });
196
196
  return (0, smithy_client_1.decorateServiceException)(exception, body);
197
197
  };
198
- const deserializeAws_json1_1SerialConsoleAccessDisabledExceptionResponse = async (parsedOutput, context) => {
198
+ const de_SerialConsoleAccessDisabledExceptionRes = async (parsedOutput, context) => {
199
199
  const body = parsedOutput.body;
200
- const deserialized = deserializeAws_json1_1SerialConsoleAccessDisabledException(body, context);
200
+ const deserialized = de_SerialConsoleAccessDisabledException(body, context);
201
201
  const exception = new models_0_1.SerialConsoleAccessDisabledException({
202
202
  $metadata: deserializeMetadata(parsedOutput),
203
203
  ...deserialized,
204
204
  });
205
205
  return (0, smithy_client_1.decorateServiceException)(exception, body);
206
206
  };
207
- const deserializeAws_json1_1SerialConsoleSessionLimitExceededExceptionResponse = async (parsedOutput, context) => {
207
+ const de_SerialConsoleSessionLimitExceededExceptionRes = async (parsedOutput, context) => {
208
208
  const body = parsedOutput.body;
209
- const deserialized = deserializeAws_json1_1SerialConsoleSessionLimitExceededException(body, context);
209
+ const deserialized = de_SerialConsoleSessionLimitExceededException(body, context);
210
210
  const exception = new models_0_1.SerialConsoleSessionLimitExceededException({
211
211
  $metadata: deserializeMetadata(parsedOutput),
212
212
  ...deserialized,
213
213
  });
214
214
  return (0, smithy_client_1.decorateServiceException)(exception, body);
215
215
  };
216
- const deserializeAws_json1_1SerialConsoleSessionUnavailableExceptionResponse = async (parsedOutput, context) => {
216
+ const de_SerialConsoleSessionUnavailableExceptionRes = async (parsedOutput, context) => {
217
217
  const body = parsedOutput.body;
218
- const deserialized = deserializeAws_json1_1SerialConsoleSessionUnavailableException(body, context);
218
+ const deserialized = de_SerialConsoleSessionUnavailableException(body, context);
219
219
  const exception = new models_0_1.SerialConsoleSessionUnavailableException({
220
220
  $metadata: deserializeMetadata(parsedOutput),
221
221
  ...deserialized,
222
222
  });
223
223
  return (0, smithy_client_1.decorateServiceException)(exception, body);
224
224
  };
225
- const deserializeAws_json1_1ServiceExceptionResponse = async (parsedOutput, context) => {
225
+ const de_ServiceExceptionRes = async (parsedOutput, context) => {
226
226
  const body = parsedOutput.body;
227
- const deserialized = deserializeAws_json1_1ServiceException(body, context);
227
+ const deserialized = de_ServiceException(body, context);
228
228
  const exception = new models_0_1.ServiceException({
229
229
  $metadata: deserializeMetadata(parsedOutput),
230
230
  ...deserialized,
231
231
  });
232
232
  return (0, smithy_client_1.decorateServiceException)(exception, body);
233
233
  };
234
- const deserializeAws_json1_1ThrottlingExceptionResponse = async (parsedOutput, context) => {
234
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
235
235
  const body = parsedOutput.body;
236
- const deserialized = deserializeAws_json1_1ThrottlingException(body, context);
236
+ const deserialized = de_ThrottlingException(body, context);
237
237
  const exception = new models_0_1.ThrottlingException({
238
238
  $metadata: deserializeMetadata(parsedOutput),
239
239
  ...deserialized,
240
240
  });
241
241
  return (0, smithy_client_1.decorateServiceException)(exception, body);
242
242
  };
243
- const serializeAws_json1_1SendSerialConsoleSSHPublicKeyRequest = (input, context) => {
243
+ const se_SendSerialConsoleSSHPublicKeyRequest = (input, context) => {
244
244
  return {
245
245
  ...(input.InstanceId != null && { InstanceId: input.InstanceId }),
246
246
  ...(input.SSHPublicKey != null && { SSHPublicKey: input.SSHPublicKey }),
247
247
  ...(input.SerialPort != null && { SerialPort: input.SerialPort }),
248
248
  };
249
249
  };
250
- const serializeAws_json1_1SendSSHPublicKeyRequest = (input, context) => {
250
+ const se_SendSSHPublicKeyRequest = (input, context) => {
251
251
  return {
252
252
  ...(input.AvailabilityZone != null && { AvailabilityZone: input.AvailabilityZone }),
253
253
  ...(input.InstanceId != null && { InstanceId: input.InstanceId }),
@@ -255,69 +255,69 @@ const serializeAws_json1_1SendSSHPublicKeyRequest = (input, context) => {
255
255
  ...(input.SSHPublicKey != null && { SSHPublicKey: input.SSHPublicKey }),
256
256
  };
257
257
  };
258
- const deserializeAws_json1_1AuthException = (output, context) => {
258
+ const de_AuthException = (output, context) => {
259
259
  return {
260
260
  Message: (0, smithy_client_1.expectString)(output.Message),
261
261
  };
262
262
  };
263
- const deserializeAws_json1_1EC2InstanceNotFoundException = (output, context) => {
263
+ const de_EC2InstanceNotFoundException = (output, context) => {
264
264
  return {
265
265
  Message: (0, smithy_client_1.expectString)(output.Message),
266
266
  };
267
267
  };
268
- const deserializeAws_json1_1EC2InstanceStateInvalidException = (output, context) => {
268
+ const de_EC2InstanceStateInvalidException = (output, context) => {
269
269
  return {
270
270
  Message: (0, smithy_client_1.expectString)(output.Message),
271
271
  };
272
272
  };
273
- const deserializeAws_json1_1EC2InstanceTypeInvalidException = (output, context) => {
273
+ const de_EC2InstanceTypeInvalidException = (output, context) => {
274
274
  return {
275
275
  Message: (0, smithy_client_1.expectString)(output.Message),
276
276
  };
277
277
  };
278
- const deserializeAws_json1_1EC2InstanceUnavailableException = (output, context) => {
278
+ const de_EC2InstanceUnavailableException = (output, context) => {
279
279
  return {
280
280
  Message: (0, smithy_client_1.expectString)(output.Message),
281
281
  };
282
282
  };
283
- const deserializeAws_json1_1InvalidArgsException = (output, context) => {
283
+ const de_InvalidArgsException = (output, context) => {
284
284
  return {
285
285
  Message: (0, smithy_client_1.expectString)(output.Message),
286
286
  };
287
287
  };
288
- const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyResponse = (output, context) => {
288
+ const de_SendSerialConsoleSSHPublicKeyResponse = (output, context) => {
289
289
  return {
290
290
  RequestId: (0, smithy_client_1.expectString)(output.RequestId),
291
291
  Success: (0, smithy_client_1.expectBoolean)(output.Success),
292
292
  };
293
293
  };
294
- const deserializeAws_json1_1SendSSHPublicKeyResponse = (output, context) => {
294
+ const de_SendSSHPublicKeyResponse = (output, context) => {
295
295
  return {
296
296
  RequestId: (0, smithy_client_1.expectString)(output.RequestId),
297
297
  Success: (0, smithy_client_1.expectBoolean)(output.Success),
298
298
  };
299
299
  };
300
- const deserializeAws_json1_1SerialConsoleAccessDisabledException = (output, context) => {
300
+ const de_SerialConsoleAccessDisabledException = (output, context) => {
301
301
  return {
302
302
  Message: (0, smithy_client_1.expectString)(output.Message),
303
303
  };
304
304
  };
305
- const deserializeAws_json1_1SerialConsoleSessionLimitExceededException = (output, context) => {
305
+ const de_SerialConsoleSessionLimitExceededException = (output, context) => {
306
306
  return {
307
307
  Message: (0, smithy_client_1.expectString)(output.Message),
308
308
  };
309
309
  };
310
- const deserializeAws_json1_1SerialConsoleSessionUnavailableException = (output, context) => {
310
+ const de_SerialConsoleSessionUnavailableException = (output, context) => {
311
311
  return {
312
312
  Message: (0, smithy_client_1.expectString)(output.Message),
313
313
  };
314
314
  };
315
- const deserializeAws_json1_1ServiceException = (output, context) => {
315
+ const de_ServiceException = (output, context) => {
316
316
  return {
317
317
  Message: (0, smithy_client_1.expectString)(output.Message),
318
318
  };
319
319
  };
320
- const deserializeAws_json1_1ThrottlingException = (output, context) => {
320
+ const de_ThrottlingException = (output, context) => {
321
321
  return {
322
322
  Message: (0, smithy_client_1.expectString)(output.Message),
323
323
  };
package/dist-es/commands/SendSSHPublicKeyCommand.js CHANGED
@@ -1,7 +1,7 @@
1
1
  import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
2
2
  import { getSerdePlugin } from "@aws-sdk/middleware-serde";
3
3
  import { Command as $Command } from "@aws-sdk/smithy-client";
4
- import { deserializeAws_json1_1SendSSHPublicKeyCommand, serializeAws_json1_1SendSSHPublicKeyCommand, } from "../protocols/Aws_json1_1";
4
+ import { de_SendSSHPublicKeyCommand, se_SendSSHPublicKeyCommand } from "../protocols/Aws_json1_1";
5
5
  export class SendSSHPublicKeyCommand extends $Command {
6
6
  static getEndpointParameterInstructions() {
7
7
  return {
@@ -33,9 +33,9 @@ export class SendSSHPublicKeyCommand extends $Command {
33
33
  return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
34
34
  }
35
35
  serialize(input, context) {
36
- return serializeAws_json1_1SendSSHPublicKeyCommand(input, context);
36
+ return se_SendSSHPublicKeyCommand(input, context);
37
37
  }
38
38
  deserialize(output, context) {
39
- return deserializeAws_json1_1SendSSHPublicKeyCommand(output, context);
39
+ return de_SendSSHPublicKeyCommand(output, context);
40
40
  }
41
41
  }
package/dist-es/commands/SendSerialConsoleSSHPublicKeyCommand.js CHANGED
@@ -1,7 +1,7 @@
1
1
  import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
2
2
  import { getSerdePlugin } from "@aws-sdk/middleware-serde";
3
3
  import { Command as $Command } from "@aws-sdk/smithy-client";
4
- import { deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand, serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand, } from "../protocols/Aws_json1_1";
4
+ import { de_SendSerialConsoleSSHPublicKeyCommand, se_SendSerialConsoleSSHPublicKeyCommand, } from "../protocols/Aws_json1_1";
5
5
  export class SendSerialConsoleSSHPublicKeyCommand extends $Command {
6
6
  static getEndpointParameterInstructions() {
7
7
  return {
@@ -33,9 +33,9 @@ export class SendSerialConsoleSSHPublicKeyCommand extends $Command {
33
33
  return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
34
34
  }
35
35
  serialize(input, context) {
36
- return serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand(input, context);
36
+ return se_SendSerialConsoleSSHPublicKeyCommand(input, context);
37
37
  }
38
38
  deserialize(output, context) {
39
- return deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand(output, context);
39
+ return de_SendSerialConsoleSSHPublicKeyCommand(output, context);
40
40
  }
41
41
  }
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -2,38 +2,38 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
2
2
  import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectString as __expectString, throwDefaultError, } from "@aws-sdk/smithy-client";
3
3
  import { EC2InstanceConnectServiceException as __BaseException } from "../models/EC2InstanceConnectServiceException";
4
4
  import { AuthException, EC2InstanceNotFoundException, EC2InstanceStateInvalidException, EC2InstanceTypeInvalidException, EC2InstanceUnavailableException, InvalidArgsException, SerialConsoleAccessDisabledException, SerialConsoleSessionLimitExceededException, SerialConsoleSessionUnavailableException, ServiceException, ThrottlingException, } from "../models/models_0";
5
- export const serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = async (input, context) => {
5
+ export const se_SendSerialConsoleSSHPublicKeyCommand = async (input, context) => {
6
6
  const headers = {
7
7
  "content-type": "application/x-amz-json-1.1",
8
8
  "x-amz-target": "AWSEC2InstanceConnectService.SendSerialConsoleSSHPublicKey",
9
9
  };
10
10
  let body;
11
- body = JSON.stringify(serializeAws_json1_1SendSerialConsoleSSHPublicKeyRequest(input, context));
11
+ body = JSON.stringify(se_SendSerialConsoleSSHPublicKeyRequest(input, context));
12
12
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
13
13
  };
14
- export const serializeAws_json1_1SendSSHPublicKeyCommand = async (input, context) => {
14
+ export const se_SendSSHPublicKeyCommand = async (input, context) => {
15
15
  const headers = {
16
16
  "content-type": "application/x-amz-json-1.1",
17
17
  "x-amz-target": "AWSEC2InstanceConnectService.SendSSHPublicKey",
18
18
  };
19
19
  let body;
20
- body = JSON.stringify(serializeAws_json1_1SendSSHPublicKeyRequest(input, context));
20
+ body = JSON.stringify(se_SendSSHPublicKeyRequest(input, context));
21
21
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
22
22
  };
23
- export const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand = async (output, context) => {
23
+ export const de_SendSerialConsoleSSHPublicKeyCommand = async (output, context) => {
24
24
  if (output.statusCode >= 300) {
25
- return deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError(output, context);
25
+ return de_SendSerialConsoleSSHPublicKeyCommandError(output, context);
26
26
  }
27
27
  const data = await parseBody(output.body, context);
28
28
  let contents = {};
29
- contents = deserializeAws_json1_1SendSerialConsoleSSHPublicKeyResponse(data, context);
29
+ contents = de_SendSerialConsoleSSHPublicKeyResponse(data, context);
30
30
  const response = {
31
31
  $metadata: deserializeMetadata(output),
32
32
  ...contents,
33
33
  };
34
34
  return Promise.resolve(response);
35
35
  };
36
- const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (output, context) => {
36
+ const de_SendSerialConsoleSSHPublicKeyCommandError = async (output, context) => {
37
37
  const parsedOutput = {
38
38
  ...output,
39
39
  body: await parseErrorBody(output.body, context),
@@ -42,37 +42,37 @@ const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (o
42
42
  switch (errorCode) {
43
43
  case "AuthException":
44
44
  case "com.amazonaws.ec2instanceconnect#AuthException":
45
- throw await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context);
45
+ throw await de_AuthExceptionRes(parsedOutput, context);
46
46
  case "EC2InstanceNotFoundException":
47
47
  case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
48
- throw await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context);
48
+ throw await de_EC2InstanceNotFoundExceptionRes(parsedOutput, context);
49
49
  case "EC2InstanceStateInvalidException":
50
50
  case "com.amazonaws.ec2instanceconnect#EC2InstanceStateInvalidException":
51
- throw await deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse(parsedOutput, context);
51
+ throw await de_EC2InstanceStateInvalidExceptionRes(parsedOutput, context);
52
52
  case "EC2InstanceTypeInvalidException":
53
53
  case "com.amazonaws.ec2instanceconnect#EC2InstanceTypeInvalidException":
54
- throw await deserializeAws_json1_1EC2InstanceTypeInvalidExceptionResponse(parsedOutput, context);
54
+ throw await de_EC2InstanceTypeInvalidExceptionRes(parsedOutput, context);
55
55
  case "EC2InstanceUnavailableException":
56
56
  case "com.amazonaws.ec2instanceconnect#EC2InstanceUnavailableException":
57
- throw await deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse(parsedOutput, context);
57
+ throw await de_EC2InstanceUnavailableExceptionRes(parsedOutput, context);
58
58
  case "InvalidArgsException":
59
59
  case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
60
- throw await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context);
60
+ throw await de_InvalidArgsExceptionRes(parsedOutput, context);
61
61
  case "SerialConsoleAccessDisabledException":
62
62
  case "com.amazonaws.ec2instanceconnect#SerialConsoleAccessDisabledException":
63
- throw await deserializeAws_json1_1SerialConsoleAccessDisabledExceptionResponse(parsedOutput, context);
63
+ throw await de_SerialConsoleAccessDisabledExceptionRes(parsedOutput, context);
64
64
  case "SerialConsoleSessionLimitExceededException":
65
65
  case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionLimitExceededException":
66
- throw await deserializeAws_json1_1SerialConsoleSessionLimitExceededExceptionResponse(parsedOutput, context);
66
+ throw await de_SerialConsoleSessionLimitExceededExceptionRes(parsedOutput, context);
67
67
  case "SerialConsoleSessionUnavailableException":
68
68
  case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionUnavailableException":
69
- throw await deserializeAws_json1_1SerialConsoleSessionUnavailableExceptionResponse(parsedOutput, context);
69
+ throw await de_SerialConsoleSessionUnavailableExceptionRes(parsedOutput, context);
70
70
  case "ServiceException":
71
71
  case "com.amazonaws.ec2instanceconnect#ServiceException":
72
- throw await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context);
72
+ throw await de_ServiceExceptionRes(parsedOutput, context);
73
73
  case "ThrottlingException":
74
74
  case "com.amazonaws.ec2instanceconnect#ThrottlingException":
75
- throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
75
+ throw await de_ThrottlingExceptionRes(parsedOutput, context);
76
76
  default:
77
77
  const parsedBody = parsedOutput.body;
78
78
  throwDefaultError({
@@ -83,20 +83,20 @@ const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError = async (o
83
83
  });
84
84
  }
85
85
  };
86
- export const deserializeAws_json1_1SendSSHPublicKeyCommand = async (output, context) => {
86
+ export const de_SendSSHPublicKeyCommand = async (output, context) => {
87
87
  if (output.statusCode >= 300) {
88
- return deserializeAws_json1_1SendSSHPublicKeyCommandError(output, context);
88
+ return de_SendSSHPublicKeyCommandError(output, context);
89
89
  }
90
90
  const data = await parseBody(output.body, context);
91
91
  let contents = {};
92
- contents = deserializeAws_json1_1SendSSHPublicKeyResponse(data, context);
92
+ contents = de_SendSSHPublicKeyResponse(data, context);
93
93
  const response = {
94
94
  $metadata: deserializeMetadata(output),
95
95
  ...contents,
96
96
  };
97
97
  return Promise.resolve(response);
98
98
  };
99
- const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, context) => {
99
+ const de_SendSSHPublicKeyCommandError = async (output, context) => {
100
100
  const parsedOutput = {
101
101
  ...output,
102
102
  body: await parseErrorBody(output.body, context),
@@ -105,25 +105,25 @@ const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, contex
105
105
  switch (errorCode) {
106
106
  case "AuthException":
107
107
  case "com.amazonaws.ec2instanceconnect#AuthException":
108
- throw await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context);
108
+ throw await de_AuthExceptionRes(parsedOutput, context);
109
109
  case "EC2InstanceNotFoundException":
110
110
  case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
111
- throw await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context);
111
+ throw await de_EC2InstanceNotFoundExceptionRes(parsedOutput, context);
112
112
  case "EC2InstanceStateInvalidException":
113
113
  case "com.amazonaws.ec2instanceconnect#EC2InstanceStateInvalidException":
114
- throw await deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse(parsedOutput, context);
114
+ throw await de_EC2InstanceStateInvalidExceptionRes(parsedOutput, context);
115
115
  case "EC2InstanceUnavailableException":
116
116
  case "com.amazonaws.ec2instanceconnect#EC2InstanceUnavailableException":
117
- throw await deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse(parsedOutput, context);
117
+ throw await de_EC2InstanceUnavailableExceptionRes(parsedOutput, context);
118
118
  case "InvalidArgsException":
119
119
  case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
120
- throw await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context);
120
+ throw await de_InvalidArgsExceptionRes(parsedOutput, context);
121
121
  case "ServiceException":
122
122
  case "com.amazonaws.ec2instanceconnect#ServiceException":
123
- throw await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context);
123
+ throw await de_ServiceExceptionRes(parsedOutput, context);
124
124
  case "ThrottlingException":
125
125
  case "com.amazonaws.ec2instanceconnect#ThrottlingException":
126
- throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
126
+ throw await de_ThrottlingExceptionRes(parsedOutput, context);
127
127
  default:
128
128
  const parsedBody = parsedOutput.body;
129
129
  throwDefaultError({
@@ -134,113 +134,113 @@ const deserializeAws_json1_1SendSSHPublicKeyCommandError = async (output, contex
134
134
  });
135
135
  }
136
136
  };
137
- const deserializeAws_json1_1AuthExceptionResponse = async (parsedOutput, context) => {
137
+ const de_AuthExceptionRes = async (parsedOutput, context) => {
138
138
  const body = parsedOutput.body;
139
- const deserialized = deserializeAws_json1_1AuthException(body, context);
139
+ const deserialized = de_AuthException(body, context);
140
140
  const exception = new AuthException({
141
141
  $metadata: deserializeMetadata(parsedOutput),
142
142
  ...deserialized,
143
143
  });
144
144
  return __decorateServiceException(exception, body);
145
145
  };
146
- const deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse = async (parsedOutput, context) => {
146
+ const de_EC2InstanceNotFoundExceptionRes = async (parsedOutput, context) => {
147
147
  const body = parsedOutput.body;
148
- const deserialized = deserializeAws_json1_1EC2InstanceNotFoundException(body, context);
148
+ const deserialized = de_EC2InstanceNotFoundException(body, context);
149
149
  const exception = new EC2InstanceNotFoundException({
150
150
  $metadata: deserializeMetadata(parsedOutput),
151
151
  ...deserialized,
152
152
  });
153
153
  return __decorateServiceException(exception, body);
154
154
  };
155
- const deserializeAws_json1_1EC2InstanceStateInvalidExceptionResponse = async (parsedOutput, context) => {
155
+ const de_EC2InstanceStateInvalidExceptionRes = async (parsedOutput, context) => {
156
156
  const body = parsedOutput.body;
157
- const deserialized = deserializeAws_json1_1EC2InstanceStateInvalidException(body, context);
157
+ const deserialized = de_EC2InstanceStateInvalidException(body, context);
158
158
  const exception = new EC2InstanceStateInvalidException({
159
159
  $metadata: deserializeMetadata(parsedOutput),
160
160
  ...deserialized,
161
161
  });
162
162
  return __decorateServiceException(exception, body);
163
163
  };
164
- const deserializeAws_json1_1EC2InstanceTypeInvalidExceptionResponse = async (parsedOutput, context) => {
164
+ const de_EC2InstanceTypeInvalidExceptionRes = async (parsedOutput, context) => {
165
165
  const body = parsedOutput.body;
166
- const deserialized = deserializeAws_json1_1EC2InstanceTypeInvalidException(body, context);
166
+ const deserialized = de_EC2InstanceTypeInvalidException(body, context);
167
167
  const exception = new EC2InstanceTypeInvalidException({
168
168
  $metadata: deserializeMetadata(parsedOutput),
169
169
  ...deserialized,
170
170
  });
171
171
  return __decorateServiceException(exception, body);
172
172
  };
173
- const deserializeAws_json1_1EC2InstanceUnavailableExceptionResponse = async (parsedOutput, context) => {
173
+ const de_EC2InstanceUnavailableExceptionRes = async (parsedOutput, context) => {
174
174
  const body = parsedOutput.body;
175
- const deserialized = deserializeAws_json1_1EC2InstanceUnavailableException(body, context);
175
+ const deserialized = de_EC2InstanceUnavailableException(body, context);
176
176
  const exception = new EC2InstanceUnavailableException({
177
177
  $metadata: deserializeMetadata(parsedOutput),
178
178
  ...deserialized,
179
179
  });
180
180
  return __decorateServiceException(exception, body);
181
181
  };
182
- const deserializeAws_json1_1InvalidArgsExceptionResponse = async (parsedOutput, context) => {
182
+ const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
183
183
  const body = parsedOutput.body;
184
- const deserialized = deserializeAws_json1_1InvalidArgsException(body, context);
184
+ const deserialized = de_InvalidArgsException(body, context);
185
185
  const exception = new InvalidArgsException({
186
186
  $metadata: deserializeMetadata(parsedOutput),
187
187
  ...deserialized,
188
188
  });
189
189
  return __decorateServiceException(exception, body);
190
190
  };
191
- const deserializeAws_json1_1SerialConsoleAccessDisabledExceptionResponse = async (parsedOutput, context) => {
191
+ const de_SerialConsoleAccessDisabledExceptionRes = async (parsedOutput, context) => {
192
192
  const body = parsedOutput.body;
193
- const deserialized = deserializeAws_json1_1SerialConsoleAccessDisabledException(body, context);
193
+ const deserialized = de_SerialConsoleAccessDisabledException(body, context);
194
194
  const exception = new SerialConsoleAccessDisabledException({
195
195
  $metadata: deserializeMetadata(parsedOutput),
196
196
  ...deserialized,
197
197
  });
198
198
  return __decorateServiceException(exception, body);
199
199
  };
200
- const deserializeAws_json1_1SerialConsoleSessionLimitExceededExceptionResponse = async (parsedOutput, context) => {
200
+ const de_SerialConsoleSessionLimitExceededExceptionRes = async (parsedOutput, context) => {
201
201
  const body = parsedOutput.body;
202
- const deserialized = deserializeAws_json1_1SerialConsoleSessionLimitExceededException(body, context);
202
+ const deserialized = de_SerialConsoleSessionLimitExceededException(body, context);
203
203
  const exception = new SerialConsoleSessionLimitExceededException({
204
204
  $metadata: deserializeMetadata(parsedOutput),
205
205
  ...deserialized,
206
206
  });
207
207
  return __decorateServiceException(exception, body);
208
208
  };
209
- const deserializeAws_json1_1SerialConsoleSessionUnavailableExceptionResponse = async (parsedOutput, context) => {
209
+ const de_SerialConsoleSessionUnavailableExceptionRes = async (parsedOutput, context) => {
210
210
  const body = parsedOutput.body;
211
- const deserialized = deserializeAws_json1_1SerialConsoleSessionUnavailableException(body, context);
211
+ const deserialized = de_SerialConsoleSessionUnavailableException(body, context);
212
212
  const exception = new SerialConsoleSessionUnavailableException({
213
213
  $metadata: deserializeMetadata(parsedOutput),
214
214
  ...deserialized,
215
215
  });
216
216
  return __decorateServiceException(exception, body);
217
217
  };
218
- const deserializeAws_json1_1ServiceExceptionResponse = async (parsedOutput, context) => {
218
+ const de_ServiceExceptionRes = async (parsedOutput, context) => {
219
219
  const body = parsedOutput.body;
220
- const deserialized = deserializeAws_json1_1ServiceException(body, context);
220
+ const deserialized = de_ServiceException(body, context);
221
221
  const exception = new ServiceException({
222
222
  $metadata: deserializeMetadata(parsedOutput),
223
223
  ...deserialized,
224
224
  });
225
225
  return __decorateServiceException(exception, body);
226
226
  };
227
- const deserializeAws_json1_1ThrottlingExceptionResponse = async (parsedOutput, context) => {
227
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
228
228
  const body = parsedOutput.body;
229
- const deserialized = deserializeAws_json1_1ThrottlingException(body, context);
229
+ const deserialized = de_ThrottlingException(body, context);
230
230
  const exception = new ThrottlingException({
231
231
  $metadata: deserializeMetadata(parsedOutput),
232
232
  ...deserialized,
233
233
  });
234
234
  return __decorateServiceException(exception, body);
235
235
  };
236
- const serializeAws_json1_1SendSerialConsoleSSHPublicKeyRequest = (input, context) => {
236
+ const se_SendSerialConsoleSSHPublicKeyRequest = (input, context) => {
237
237
  return {
238
238
  ...(input.InstanceId != null && { InstanceId: input.InstanceId }),
239
239
  ...(input.SSHPublicKey != null && { SSHPublicKey: input.SSHPublicKey }),
240
240
  ...(input.SerialPort != null && { SerialPort: input.SerialPort }),
241
241
  };
242
242
  };
243
- const serializeAws_json1_1SendSSHPublicKeyRequest = (input, context) => {
243
+ const se_SendSSHPublicKeyRequest = (input, context) => {
244
244
  return {
245
245
  ...(input.AvailabilityZone != null && { AvailabilityZone: input.AvailabilityZone }),
246
246
  ...(input.InstanceId != null && { InstanceId: input.InstanceId }),
@@ -248,69 +248,69 @@ const serializeAws_json1_1SendSSHPublicKeyRequest = (input, context) => {
248
248
  ...(input.SSHPublicKey != null && { SSHPublicKey: input.SSHPublicKey }),
249
249
  };
250
250
  };
251
- const deserializeAws_json1_1AuthException = (output, context) => {
251
+ const de_AuthException = (output, context) => {
252
252
  return {
253
253
  Message: __expectString(output.Message),
254
254
  };
255
255
  };
256
- const deserializeAws_json1_1EC2InstanceNotFoundException = (output, context) => {
256
+ const de_EC2InstanceNotFoundException = (output, context) => {
257
257
  return {
258
258
  Message: __expectString(output.Message),
259
259
  };
260
260
  };
261
- const deserializeAws_json1_1EC2InstanceStateInvalidException = (output, context) => {
261
+ const de_EC2InstanceStateInvalidException = (output, context) => {
262
262
  return {
263
263
  Message: __expectString(output.Message),
264
264
  };
265
265
  };
266
- const deserializeAws_json1_1EC2InstanceTypeInvalidException = (output, context) => {
266
+ const de_EC2InstanceTypeInvalidException = (output, context) => {
267
267
  return {
268
268
  Message: __expectString(output.Message),
269
269
  };
270
270
  };
271
- const deserializeAws_json1_1EC2InstanceUnavailableException = (output, context) => {
271
+ const de_EC2InstanceUnavailableException = (output, context) => {
272
272
  return {
273
273
  Message: __expectString(output.Message),
274
274
  };
275
275
  };
276
- const deserializeAws_json1_1InvalidArgsException = (output, context) => {
276
+ const de_InvalidArgsException = (output, context) => {
277
277
  return {
278
278
  Message: __expectString(output.Message),
279
279
  };
280
280
  };
281
- const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyResponse = (output, context) => {
281
+ const de_SendSerialConsoleSSHPublicKeyResponse = (output, context) => {
282
282
  return {
283
283
  RequestId: __expectString(output.RequestId),
284
284
  Success: __expectBoolean(output.Success),
285
285
  };
286
286
  };
287
- const deserializeAws_json1_1SendSSHPublicKeyResponse = (output, context) => {
287
+ const de_SendSSHPublicKeyResponse = (output, context) => {
288
288
  return {
289
289
  RequestId: __expectString(output.RequestId),
290
290
  Success: __expectBoolean(output.Success),
291
291
  };
292
292
  };
293
- const deserializeAws_json1_1SerialConsoleAccessDisabledException = (output, context) => {
293
+ const de_SerialConsoleAccessDisabledException = (output, context) => {
294
294
  return {
295
295
  Message: __expectString(output.Message),
296
296
  };
297
297
  };
298
- const deserializeAws_json1_1SerialConsoleSessionLimitExceededException = (output, context) => {
298
+ const de_SerialConsoleSessionLimitExceededException = (output, context) => {
299
299
  return {
300
300
  Message: __expectString(output.Message),
301
301
  };
302
302
  };
303
- const deserializeAws_json1_1SerialConsoleSessionUnavailableException = (output, context) => {
303
+ const de_SerialConsoleSessionUnavailableException = (output, context) => {
304
304
  return {
305
305
  Message: __expectString(output.Message),
306
306
  };
307
307
  };
308
- const deserializeAws_json1_1ServiceException = (output, context) => {
308
+ const de_ServiceException = (output, context) => {
309
309
  return {
310
310
  Message: __expectString(output.Message),
311
311
  };
312
312
  };
313
- const deserializeAws_json1_1ThrottlingException = (output, context) => {
313
+ const de_ThrottlingException = (output, context) => {
314
314
  return {
315
315
  Message: __expectString(output.Message),
316
316
  };
package/dist-types/protocols/Aws_json1_1.d.ts CHANGED
@@ -2,7 +2,19 @@ import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@a
2
2
  import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
3
3
  import { SendSerialConsoleSSHPublicKeyCommandInput, SendSerialConsoleSSHPublicKeyCommandOutput } from "../commands/SendSerialConsoleSSHPublicKeyCommand";
4
4
  import { SendSSHPublicKeyCommandInput, SendSSHPublicKeyCommandOutput } from "../commands/SendSSHPublicKeyCommand";
5
- export declare const serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand: (input: SendSerialConsoleSSHPublicKeyCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
6
- export declare const serializeAws_json1_1SendSSHPublicKeyCommand: (input: SendSSHPublicKeyCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
7
- export declare const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SendSerialConsoleSSHPublicKeyCommandOutput>;
8
- export declare const deserializeAws_json1_1SendSSHPublicKeyCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SendSSHPublicKeyCommandOutput>;
5
+ /**
6
+ * serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand
7
+ */
8
+ export declare const se_SendSerialConsoleSSHPublicKeyCommand: (input: SendSerialConsoleSSHPublicKeyCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
9
+ /**
10
+ * serializeAws_json1_1SendSSHPublicKeyCommand
11
+ */
12
+ export declare const se_SendSSHPublicKeyCommand: (input: SendSSHPublicKeyCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
13
+ /**
14
+ * deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand
15
+ */
16
+ export declare const de_SendSerialConsoleSSHPublicKeyCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SendSerialConsoleSSHPublicKeyCommandOutput>;
17
+ /**
18
+ * deserializeAws_json1_1SendSSHPublicKeyCommand
19
+ */
20
+ export declare const de_SendSSHPublicKeyCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SendSSHPublicKeyCommandOutput>;
package/dist-types/ts3.4/protocols/Aws_json1_1.d.ts CHANGED
@@ -11,19 +11,19 @@ import {
11
11
  SendSSHPublicKeyCommandInput,
12
12
  SendSSHPublicKeyCommandOutput,
13
13
  } from "../commands/SendSSHPublicKeyCommand";
14
- export declare const serializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand: (
14
+ export declare const se_SendSerialConsoleSSHPublicKeyCommand: (
15
15
  input: SendSerialConsoleSSHPublicKeyCommandInput,
16
16
  context: __SerdeContext
17
17
  ) => Promise<__HttpRequest>;
18
- export declare const serializeAws_json1_1SendSSHPublicKeyCommand: (
18
+ export declare const se_SendSSHPublicKeyCommand: (
19
19
  input: SendSSHPublicKeyCommandInput,
20
20
  context: __SerdeContext
21
21
  ) => Promise<__HttpRequest>;
22
- export declare const deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommand: (
22
+ export declare const de_SendSerialConsoleSSHPublicKeyCommand: (
23
23
  output: __HttpResponse,
24
24
  context: __SerdeContext
25
25
  ) => Promise<SendSerialConsoleSSHPublicKeyCommandOutput>;
26
- export declare const deserializeAws_json1_1SendSSHPublicKeyCommand: (
26
+ export declare const de_SendSSHPublicKeyCommand: (
27
27
  output: __HttpResponse,
28
28
  context: __SerdeContext
29
29
  ) => Promise<SendSSHPublicKeyCommandOutput>;
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-ec2-instance-connect",
3
3
  "description": "AWS SDK for JavaScript Ec2 Instance Connect Client for Node.js, Browser and React Native",
4
- "version": "3.306.0",
4
+ "version": "3.309.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -21,9 +21,9 @@
21
21
  "dependencies": {
22
22
  "@aws-crypto/sha256-browser": "3.0.0",
23
23
  "@aws-crypto/sha256-js": "3.0.0",
24
- "@aws-sdk/client-sts": "3.306.0",
24
+ "@aws-sdk/client-sts": "3.309.0",
25
25
  "@aws-sdk/config-resolver": "3.306.0",
26
- "@aws-sdk/credential-provider-node": "3.306.0",
26
+ "@aws-sdk/credential-provider-node": "3.309.0",
27
27
  "@aws-sdk/fetch-http-handler": "3.306.0",
28
28
  "@aws-sdk/hash-node": "3.306.0",
29
29
  "@aws-sdk/invalid-dependency": "3.306.0",
@@ -40,14 +40,14 @@
40
40
  "@aws-sdk/node-config-provider": "3.306.0",
41
41
  "@aws-sdk/node-http-handler": "3.306.0",
42
42
  "@aws-sdk/protocol-http": "3.306.0",
43
- "@aws-sdk/smithy-client": "3.306.0",
43
+ "@aws-sdk/smithy-client": "3.309.0",
44
44
  "@aws-sdk/types": "3.306.0",
45
45
  "@aws-sdk/url-parser": "3.306.0",
46
46
  "@aws-sdk/util-base64": "3.303.0",
47
47
  "@aws-sdk/util-body-length-browser": "3.303.0",
48
48
  "@aws-sdk/util-body-length-node": "3.303.0",
49
- "@aws-sdk/util-defaults-mode-browser": "3.306.0",
50
- "@aws-sdk/util-defaults-mode-node": "3.306.0",
49
+ "@aws-sdk/util-defaults-mode-browser": "3.309.0",
50
+ "@aws-sdk/util-defaults-mode-node": "3.309.0",
51
51
  "@aws-sdk/util-endpoints": "3.306.0",
52
52
  "@aws-sdk/util-retry": "3.306.0",
53
53
  "@aws-sdk/util-user-agent-browser": "3.306.0",