@aws-sdk/client-snow-device-management 3.901.0 → 3.906.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 (2) hide show
  1. package/dist-cjs/index.js +1028 -1159
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,1210 +1,1079 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+ var uuid = require('@smithy/uuid');
20
+
21
+ const resolveClientEndpointParameters = (options) => {
22
+ return Object.assign(options, {
23
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
24
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
25
+ defaultSigningName: "snow-device-management",
26
+ });
10
27
  };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
28
+ const commonParams = {
29
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
30
+ Endpoint: { type: "builtInParams", name: "endpoint" },
31
+ Region: { type: "builtInParams", name: "region" },
32
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
18
33
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- AttachmentStatus: () => AttachmentStatus,
26
- CancelTaskCommand: () => CancelTaskCommand,
27
- Command: () => Command,
28
- CreateTaskCommand: () => CreateTaskCommand,
29
- DescribeDeviceCommand: () => DescribeDeviceCommand,
30
- DescribeDeviceEc2InstancesCommand: () => DescribeDeviceEc2InstancesCommand,
31
- DescribeExecutionCommand: () => DescribeExecutionCommand,
32
- DescribeTaskCommand: () => DescribeTaskCommand,
33
- ExecutionState: () => ExecutionState,
34
- InstanceStateName: () => InstanceStateName,
35
- InternalServerException: () => InternalServerException,
36
- IpAddressAssignment: () => IpAddressAssignment,
37
- ListDeviceResourcesCommand: () => ListDeviceResourcesCommand,
38
- ListDevicesCommand: () => ListDevicesCommand,
39
- ListExecutionsCommand: () => ListExecutionsCommand,
40
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
41
- ListTasksCommand: () => ListTasksCommand,
42
- PhysicalConnectorType: () => PhysicalConnectorType,
43
- ResourceNotFoundException: () => ResourceNotFoundException,
44
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
45
- SnowDeviceManagement: () => SnowDeviceManagement,
46
- SnowDeviceManagementClient: () => SnowDeviceManagementClient,
47
- SnowDeviceManagementServiceException: () => SnowDeviceManagementServiceException,
48
- TagResourceCommand: () => TagResourceCommand,
49
- TaskState: () => TaskState,
50
- ThrottlingException: () => ThrottlingException,
51
- UnlockState: () => UnlockState,
52
- UntagResourceCommand: () => UntagResourceCommand,
53
- ValidationException: () => ValidationException,
54
- __Client: () => import_smithy_client.Client,
55
- paginateListDeviceResources: () => paginateListDeviceResources,
56
- paginateListDevices: () => paginateListDevices,
57
- paginateListExecutions: () => paginateListExecutions,
58
- paginateListTasks: () => paginateListTasks
59
- });
60
- module.exports = __toCommonJS(index_exports);
61
-
62
- // src/SnowDeviceManagementClient.ts
63
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
64
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
65
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
66
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
67
- var import_config_resolver = require("@smithy/config-resolver");
68
- var import_core = require("@smithy/core");
69
- var import_middleware_content_length = require("@smithy/middleware-content-length");
70
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
71
- var import_middleware_retry = require("@smithy/middleware-retry");
72
-
73
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
74
34
 
75
- // src/endpoint/EndpointParameters.ts
76
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
77
- return Object.assign(options, {
78
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
79
- useFipsEndpoint: options.useFipsEndpoint ?? false,
80
- defaultSigningName: "snow-device-management"
81
- });
82
- }, "resolveClientEndpointParameters");
83
- var commonParams = {
84
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
85
- Endpoint: { type: "builtInParams", name: "endpoint" },
86
- Region: { type: "builtInParams", name: "region" },
87
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
35
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
36
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
37
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
38
+ let _credentials = runtimeConfig.credentials;
39
+ return {
40
+ setHttpAuthScheme(httpAuthScheme) {
41
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
42
+ if (index === -1) {
43
+ _httpAuthSchemes.push(httpAuthScheme);
44
+ }
45
+ else {
46
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
47
+ }
48
+ },
49
+ httpAuthSchemes() {
50
+ return _httpAuthSchemes;
51
+ },
52
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
53
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
54
+ },
55
+ httpAuthSchemeProvider() {
56
+ return _httpAuthSchemeProvider;
57
+ },
58
+ setCredentials(credentials) {
59
+ _credentials = credentials;
60
+ },
61
+ credentials() {
62
+ return _credentials;
63
+ },
64
+ };
65
+ };
66
+ const resolveHttpAuthRuntimeConfig = (config) => {
67
+ return {
68
+ httpAuthSchemes: config.httpAuthSchemes(),
69
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
70
+ credentials: config.credentials(),
71
+ };
88
72
  };
89
73
 
90
- // src/SnowDeviceManagementClient.ts
91
- var import_runtimeConfig = require("././runtimeConfig");
92
-
93
- // src/runtimeExtensions.ts
94
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
95
- var import_protocol_http = require("@smithy/protocol-http");
96
- var import_smithy_client = require("@smithy/smithy-client");
74
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
75
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
76
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
77
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
78
+ };
97
79
 
98
- // src/auth/httpAuthExtensionConfiguration.ts
99
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
100
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
101
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
102
- let _credentials = runtimeConfig.credentials;
103
- return {
104
- setHttpAuthScheme(httpAuthScheme) {
105
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
106
- if (index === -1) {
107
- _httpAuthSchemes.push(httpAuthScheme);
108
- } else {
109
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
110
- }
111
- },
112
- httpAuthSchemes() {
113
- return _httpAuthSchemes;
114
- },
115
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
116
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
117
- },
118
- httpAuthSchemeProvider() {
119
- return _httpAuthSchemeProvider;
120
- },
121
- setCredentials(credentials) {
122
- _credentials = credentials;
123
- },
124
- credentials() {
125
- return _credentials;
80
+ class SnowDeviceManagementClient extends smithyClient.Client {
81
+ config;
82
+ constructor(...[configuration]) {
83
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
84
+ super(_config_0);
85
+ this.initConfig = _config_0;
86
+ const _config_1 = resolveClientEndpointParameters(_config_0);
87
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
88
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
89
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
90
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
91
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
92
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
93
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
94
+ this.config = _config_8;
95
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
96
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
98
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
99
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
100
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
101
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
102
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSnowDeviceManagementHttpAuthSchemeParametersProvider,
103
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
104
+ "aws.auth#sigv4": config.credentials,
105
+ }),
106
+ }));
107
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
126
108
  }
127
- };
128
- }, "getHttpAuthExtensionConfiguration");
129
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
130
- return {
131
- httpAuthSchemes: config.httpAuthSchemes(),
132
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
133
- credentials: config.credentials()
134
- };
135
- }, "resolveHttpAuthRuntimeConfig");
136
-
137
- // src/runtimeExtensions.ts
138
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
139
- const extensionConfiguration = Object.assign(
140
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
141
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
142
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
143
- getHttpAuthExtensionConfiguration(runtimeConfig)
144
- );
145
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
146
- return Object.assign(
147
- runtimeConfig,
148
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
149
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
150
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
151
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
152
- );
153
- }, "resolveRuntimeExtensions");
109
+ destroy() {
110
+ super.destroy();
111
+ }
112
+ }
154
113
 
155
- // src/SnowDeviceManagementClient.ts
156
- var SnowDeviceManagementClient = class extends import_smithy_client.Client {
157
- static {
158
- __name(this, "SnowDeviceManagementClient");
159
- }
160
- /**
161
- * The resolved configuration of SnowDeviceManagementClient class. This is resolved and normalized from the {@link SnowDeviceManagementClientConfig | constructor configuration interface}.
162
- */
163
- config;
164
- constructor(...[configuration]) {
165
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
166
- super(_config_0);
167
- this.initConfig = _config_0;
168
- const _config_1 = resolveClientEndpointParameters(_config_0);
169
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
170
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
171
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
172
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
173
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
174
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
175
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
176
- this.config = _config_8;
177
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
178
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
179
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
180
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
181
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
182
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
183
- this.middlewareStack.use(
184
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
185
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultSnowDeviceManagementHttpAuthSchemeParametersProvider,
186
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
187
- "aws.auth#sigv4": config.credentials
188
- }), "identityProviderConfigProvider")
189
- })
190
- );
191
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
192
- }
193
- /**
194
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
195
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
196
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
197
- */
198
- destroy() {
199
- super.destroy();
200
- }
114
+ class SnowDeviceManagementServiceException extends smithyClient.ServiceException {
115
+ constructor(options) {
116
+ super(options);
117
+ Object.setPrototypeOf(this, SnowDeviceManagementServiceException.prototype);
118
+ }
119
+ }
120
+
121
+ class AccessDeniedException extends SnowDeviceManagementServiceException {
122
+ name = "AccessDeniedException";
123
+ $fault = "client";
124
+ constructor(opts) {
125
+ super({
126
+ name: "AccessDeniedException",
127
+ $fault: "client",
128
+ ...opts,
129
+ });
130
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
131
+ }
132
+ }
133
+ const AttachmentStatus = {
134
+ ATTACHED: "ATTACHED",
135
+ ATTACHING: "ATTACHING",
136
+ DETACHED: "DETACHED",
137
+ DETACHING: "DETACHING",
201
138
  };
202
-
203
- // src/SnowDeviceManagement.ts
204
-
205
-
206
- // src/commands/CancelTaskCommand.ts
207
-
208
- var import_middleware_serde = require("@smithy/middleware-serde");
209
-
210
-
211
- // src/protocols/Aws_restJson1.ts
212
- var import_core2 = require("@aws-sdk/core");
213
-
214
-
215
- var import_uuid = require("@smithy/uuid");
216
-
217
- // src/models/SnowDeviceManagementServiceException.ts
218
-
219
- var SnowDeviceManagementServiceException = class _SnowDeviceManagementServiceException extends import_smithy_client.ServiceException {
220
- static {
221
- __name(this, "SnowDeviceManagementServiceException");
222
- }
223
- /**
224
- * @internal
225
- */
226
- constructor(options) {
227
- super(options);
228
- Object.setPrototypeOf(this, _SnowDeviceManagementServiceException.prototype);
229
- }
139
+ class InternalServerException extends SnowDeviceManagementServiceException {
140
+ name = "InternalServerException";
141
+ $fault = "server";
142
+ $retryable = {};
143
+ constructor(opts) {
144
+ super({
145
+ name: "InternalServerException",
146
+ $fault: "server",
147
+ ...opts,
148
+ });
149
+ Object.setPrototypeOf(this, InternalServerException.prototype);
150
+ }
151
+ }
152
+ class ResourceNotFoundException extends SnowDeviceManagementServiceException {
153
+ name = "ResourceNotFoundException";
154
+ $fault = "client";
155
+ constructor(opts) {
156
+ super({
157
+ name: "ResourceNotFoundException",
158
+ $fault: "client",
159
+ ...opts,
160
+ });
161
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
162
+ }
163
+ }
164
+ class ThrottlingException extends SnowDeviceManagementServiceException {
165
+ name = "ThrottlingException";
166
+ $fault = "client";
167
+ $retryable = {
168
+ throttling: true,
169
+ };
170
+ constructor(opts) {
171
+ super({
172
+ name: "ThrottlingException",
173
+ $fault: "client",
174
+ ...opts,
175
+ });
176
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
177
+ }
178
+ }
179
+ class ValidationException extends SnowDeviceManagementServiceException {
180
+ name = "ValidationException";
181
+ $fault = "client";
182
+ constructor(opts) {
183
+ super({
184
+ name: "ValidationException",
185
+ $fault: "client",
186
+ ...opts,
187
+ });
188
+ Object.setPrototypeOf(this, ValidationException.prototype);
189
+ }
190
+ }
191
+ exports.Command = void 0;
192
+ (function (Command) {
193
+ Command.visit = (value, visitor) => {
194
+ if (value.unlock !== undefined)
195
+ return visitor.unlock(value.unlock);
196
+ if (value.reboot !== undefined)
197
+ return visitor.reboot(value.reboot);
198
+ return visitor._(value.$unknown[0], value.$unknown[1]);
199
+ };
200
+ })(exports.Command || (exports.Command = {}));
201
+ class ServiceQuotaExceededException extends SnowDeviceManagementServiceException {
202
+ name = "ServiceQuotaExceededException";
203
+ $fault = "client";
204
+ constructor(opts) {
205
+ super({
206
+ name: "ServiceQuotaExceededException",
207
+ $fault: "client",
208
+ ...opts,
209
+ });
210
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
211
+ }
212
+ }
213
+ const UnlockState = {
214
+ LOCKED: "LOCKED",
215
+ UNLOCKED: "UNLOCKED",
216
+ UNLOCKING: "UNLOCKING",
217
+ };
218
+ const IpAddressAssignment = {
219
+ DHCP: "DHCP",
220
+ STATIC: "STATIC",
221
+ };
222
+ const PhysicalConnectorType = {
223
+ QSFP: "QSFP",
224
+ RJ45: "RJ45",
225
+ RJ45_2: "RJ45_2",
226
+ SFP_PLUS: "SFP_PLUS",
227
+ WIFI: "WIFI",
228
+ };
229
+ const InstanceStateName = {
230
+ PENDING: "PENDING",
231
+ RUNNING: "RUNNING",
232
+ SHUTTING_DOWN: "SHUTTING_DOWN",
233
+ STOPPED: "STOPPED",
234
+ STOPPING: "STOPPING",
235
+ TERMINATED: "TERMINATED",
236
+ };
237
+ const ExecutionState = {
238
+ CANCELED: "CANCELED",
239
+ FAILED: "FAILED",
240
+ IN_PROGRESS: "IN_PROGRESS",
241
+ QUEUED: "QUEUED",
242
+ REJECTED: "REJECTED",
243
+ SUCCEEDED: "SUCCEEDED",
244
+ TIMED_OUT: "TIMED_OUT",
245
+ };
246
+ const TaskState = {
247
+ CANCELED: "CANCELED",
248
+ COMPLETED: "COMPLETED",
249
+ IN_PROGRESS: "IN_PROGRESS",
230
250
  };
231
251
 
232
- // src/models/models_0.ts
233
- var AccessDeniedException = class _AccessDeniedException extends SnowDeviceManagementServiceException {
234
- static {
235
- __name(this, "AccessDeniedException");
236
- }
237
- name = "AccessDeniedException";
238
- $fault = "client";
239
- /**
240
- * @internal
241
- */
242
- constructor(opts) {
243
- super({
244
- name: "AccessDeniedException",
245
- $fault: "client",
246
- ...opts
252
+ const se_CancelTaskCommand = async (input, context) => {
253
+ const b = core.requestBuilder(input, context);
254
+ const headers = {};
255
+ b.bp("/task/{taskId}/cancel");
256
+ b.p("taskId", () => input.taskId, "{taskId}", false);
257
+ let body;
258
+ b.m("POST").h(headers).b(body);
259
+ return b.build();
260
+ };
261
+ const se_CreateTaskCommand = async (input, context) => {
262
+ const b = core.requestBuilder(input, context);
263
+ const headers = {
264
+ "content-type": "application/json",
265
+ };
266
+ b.bp("/task");
267
+ let body;
268
+ body = JSON.stringify(smithyClient.take(input, {
269
+ clientToken: [true, (_) => _ ?? uuid.v4()],
270
+ command: (_) => smithyClient._json(_),
271
+ description: [],
272
+ tags: (_) => smithyClient._json(_),
273
+ targets: (_) => smithyClient._json(_),
274
+ }));
275
+ b.m("POST").h(headers).b(body);
276
+ return b.build();
277
+ };
278
+ const se_DescribeDeviceCommand = async (input, context) => {
279
+ const b = core.requestBuilder(input, context);
280
+ const headers = {};
281
+ b.bp("/managed-device/{managedDeviceId}/describe");
282
+ b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
283
+ let body;
284
+ b.m("POST").h(headers).b(body);
285
+ return b.build();
286
+ };
287
+ const se_DescribeDeviceEc2InstancesCommand = async (input, context) => {
288
+ const b = core.requestBuilder(input, context);
289
+ const headers = {
290
+ "content-type": "application/json",
291
+ };
292
+ b.bp("/managed-device/{managedDeviceId}/resources/ec2/describe");
293
+ b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
294
+ let body;
295
+ body = JSON.stringify(smithyClient.take(input, {
296
+ instanceIds: (_) => smithyClient._json(_),
297
+ }));
298
+ b.m("POST").h(headers).b(body);
299
+ return b.build();
300
+ };
301
+ const se_DescribeExecutionCommand = async (input, context) => {
302
+ const b = core.requestBuilder(input, context);
303
+ const headers = {};
304
+ b.bp("/task/{taskId}/execution/{managedDeviceId}");
305
+ b.p("taskId", () => input.taskId, "{taskId}", false);
306
+ b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
307
+ let body;
308
+ b.m("POST").h(headers).b(body);
309
+ return b.build();
310
+ };
311
+ const se_DescribeTaskCommand = async (input, context) => {
312
+ const b = core.requestBuilder(input, context);
313
+ const headers = {};
314
+ b.bp("/task/{taskId}");
315
+ b.p("taskId", () => input.taskId, "{taskId}", false);
316
+ let body;
317
+ b.m("POST").h(headers).b(body);
318
+ return b.build();
319
+ };
320
+ const se_ListDeviceResourcesCommand = async (input, context) => {
321
+ const b = core.requestBuilder(input, context);
322
+ const headers = {};
323
+ b.bp("/managed-device/{managedDeviceId}/resources");
324
+ b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
325
+ const query = smithyClient.map({
326
+ [_t]: [, input[_t]],
327
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
328
+ [_nT]: [, input[_nT]],
247
329
  });
248
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
249
- }
330
+ let body;
331
+ b.m("GET").h(headers).q(query).b(body);
332
+ return b.build();
250
333
  };
251
- var AttachmentStatus = {
252
- ATTACHED: "ATTACHED",
253
- ATTACHING: "ATTACHING",
254
- DETACHED: "DETACHED",
255
- DETACHING: "DETACHING"
334
+ const se_ListDevicesCommand = async (input, context) => {
335
+ const b = core.requestBuilder(input, context);
336
+ const headers = {};
337
+ b.bp("/managed-devices");
338
+ const query = smithyClient.map({
339
+ [_jI]: [, input[_jI]],
340
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
341
+ [_nT]: [, input[_nT]],
342
+ });
343
+ let body;
344
+ b.m("GET").h(headers).q(query).b(body);
345
+ return b.build();
256
346
  };
257
- var InternalServerException = class _InternalServerException extends SnowDeviceManagementServiceException {
258
- static {
259
- __name(this, "InternalServerException");
260
- }
261
- name = "InternalServerException";
262
- $fault = "server";
263
- $retryable = {};
264
- /**
265
- * @internal
266
- */
267
- constructor(opts) {
268
- super({
269
- name: "InternalServerException",
270
- $fault: "server",
271
- ...opts
347
+ const se_ListExecutionsCommand = async (input, context) => {
348
+ const b = core.requestBuilder(input, context);
349
+ const headers = {};
350
+ b.bp("/executions");
351
+ const query = smithyClient.map({
352
+ [_tI]: [, smithyClient.expectNonNull(input[_tI], `taskId`)],
353
+ [_s]: [, input[_s]],
354
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
355
+ [_nT]: [, input[_nT]],
272
356
  });
273
- Object.setPrototypeOf(this, _InternalServerException.prototype);
274
- }
357
+ let body;
358
+ b.m("GET").h(headers).q(query).b(body);
359
+ return b.build();
360
+ };
361
+ const se_ListTagsForResourceCommand = async (input, context) => {
362
+ const b = core.requestBuilder(input, context);
363
+ const headers = {};
364
+ b.bp("/tags/{resourceArn}");
365
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
366
+ let body;
367
+ b.m("GET").h(headers).b(body);
368
+ return b.build();
275
369
  };
276
- var ResourceNotFoundException = class _ResourceNotFoundException extends SnowDeviceManagementServiceException {
277
- static {
278
- __name(this, "ResourceNotFoundException");
279
- }
280
- name = "ResourceNotFoundException";
281
- $fault = "client";
282
- /**
283
- * @internal
284
- */
285
- constructor(opts) {
286
- super({
287
- name: "ResourceNotFoundException",
288
- $fault: "client",
289
- ...opts
370
+ const se_ListTasksCommand = async (input, context) => {
371
+ const b = core.requestBuilder(input, context);
372
+ const headers = {};
373
+ b.bp("/tasks");
374
+ const query = smithyClient.map({
375
+ [_s]: [, input[_s]],
376
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
377
+ [_nT]: [, input[_nT]],
290
378
  });
291
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
292
- }
379
+ let body;
380
+ b.m("GET").h(headers).q(query).b(body);
381
+ return b.build();
293
382
  };
294
- var ThrottlingException = class _ThrottlingException extends SnowDeviceManagementServiceException {
295
- static {
296
- __name(this, "ThrottlingException");
297
- }
298
- name = "ThrottlingException";
299
- $fault = "client";
300
- $retryable = {
301
- throttling: true
302
- };
303
- /**
304
- * @internal
305
- */
306
- constructor(opts) {
307
- super({
308
- name: "ThrottlingException",
309
- $fault: "client",
310
- ...opts
383
+ const se_TagResourceCommand = async (input, context) => {
384
+ const b = core.requestBuilder(input, context);
385
+ const headers = {
386
+ "content-type": "application/json",
387
+ };
388
+ b.bp("/tags/{resourceArn}");
389
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
390
+ let body;
391
+ body = JSON.stringify(smithyClient.take(input, {
392
+ tags: (_) => smithyClient._json(_),
393
+ }));
394
+ b.m("POST").h(headers).b(body);
395
+ return b.build();
396
+ };
397
+ const se_UntagResourceCommand = async (input, context) => {
398
+ const b = core.requestBuilder(input, context);
399
+ const headers = {};
400
+ b.bp("/tags/{resourceArn}");
401
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
402
+ const query = smithyClient.map({
403
+ [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
311
404
  });
312
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
313
- }
405
+ let body;
406
+ b.m("DELETE").h(headers).q(query).b(body);
407
+ return b.build();
314
408
  };
315
- var ValidationException = class _ValidationException extends SnowDeviceManagementServiceException {
316
- static {
317
- __name(this, "ValidationException");
318
- }
319
- name = "ValidationException";
320
- $fault = "client";
321
- /**
322
- * @internal
323
- */
324
- constructor(opts) {
325
- super({
326
- name: "ValidationException",
327
- $fault: "client",
328
- ...opts
409
+ const de_CancelTaskCommand = async (output, context) => {
410
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
411
+ return de_CommandError(output, context);
412
+ }
413
+ const contents = smithyClient.map({
414
+ $metadata: deserializeMetadata(output),
415
+ });
416
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
417
+ const doc = smithyClient.take(data, {
418
+ taskId: smithyClient.expectString,
329
419
  });
330
- Object.setPrototypeOf(this, _ValidationException.prototype);
331
- }
420
+ Object.assign(contents, doc);
421
+ return contents;
332
422
  };
333
- var Command;
334
- ((Command3) => {
335
- Command3.visit = /* @__PURE__ */ __name((value, visitor) => {
336
- if (value.unlock !== void 0) return visitor.unlock(value.unlock);
337
- if (value.reboot !== void 0) return visitor.reboot(value.reboot);
338
- return visitor._(value.$unknown[0], value.$unknown[1]);
339
- }, "visit");
340
- })(Command || (Command = {}));
341
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends SnowDeviceManagementServiceException {
342
- static {
343
- __name(this, "ServiceQuotaExceededException");
344
- }
345
- name = "ServiceQuotaExceededException";
346
- $fault = "client";
347
- /**
348
- * @internal
349
- */
350
- constructor(opts) {
351
- super({
352
- name: "ServiceQuotaExceededException",
353
- $fault: "client",
354
- ...opts
423
+ const de_CreateTaskCommand = async (output, context) => {
424
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
425
+ return de_CommandError(output, context);
426
+ }
427
+ const contents = smithyClient.map({
428
+ $metadata: deserializeMetadata(output),
429
+ });
430
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
431
+ const doc = smithyClient.take(data, {
432
+ taskArn: smithyClient.expectString,
433
+ taskId: smithyClient.expectString,
355
434
  });
356
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
357
- }
435
+ Object.assign(contents, doc);
436
+ return contents;
358
437
  };
359
- var UnlockState = {
360
- LOCKED: "LOCKED",
361
- UNLOCKED: "UNLOCKED",
362
- UNLOCKING: "UNLOCKING"
438
+ const de_DescribeDeviceCommand = async (output, context) => {
439
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
440
+ return de_CommandError(output, context);
441
+ }
442
+ const contents = smithyClient.map({
443
+ $metadata: deserializeMetadata(output),
444
+ });
445
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
446
+ const doc = smithyClient.take(data, {
447
+ associatedWithJob: smithyClient.expectString,
448
+ deviceCapacities: smithyClient._json,
449
+ deviceState: smithyClient.expectString,
450
+ deviceType: smithyClient.expectString,
451
+ lastReachedOutAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
452
+ lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
453
+ managedDeviceArn: smithyClient.expectString,
454
+ managedDeviceId: smithyClient.expectString,
455
+ physicalNetworkInterfaces: smithyClient._json,
456
+ software: smithyClient._json,
457
+ tags: smithyClient._json,
458
+ });
459
+ Object.assign(contents, doc);
460
+ return contents;
363
461
  };
364
- var IpAddressAssignment = {
365
- DHCP: "DHCP",
366
- STATIC: "STATIC"
462
+ const de_DescribeDeviceEc2InstancesCommand = async (output, context) => {
463
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
464
+ return de_CommandError(output, context);
465
+ }
466
+ const contents = smithyClient.map({
467
+ $metadata: deserializeMetadata(output),
468
+ });
469
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
470
+ const doc = smithyClient.take(data, {
471
+ instances: (_) => de_InstanceSummaryList(_),
472
+ });
473
+ Object.assign(contents, doc);
474
+ return contents;
367
475
  };
368
- var PhysicalConnectorType = {
369
- QSFP: "QSFP",
370
- RJ45: "RJ45",
371
- RJ45_2: "RJ45_2",
372
- SFP_PLUS: "SFP_PLUS",
373
- WIFI: "WIFI"
476
+ const de_DescribeExecutionCommand = async (output, context) => {
477
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
478
+ return de_CommandError(output, context);
479
+ }
480
+ const contents = smithyClient.map({
481
+ $metadata: deserializeMetadata(output),
482
+ });
483
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
484
+ const doc = smithyClient.take(data, {
485
+ executionId: smithyClient.expectString,
486
+ lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
487
+ managedDeviceId: smithyClient.expectString,
488
+ startedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
489
+ state: smithyClient.expectString,
490
+ taskId: smithyClient.expectString,
491
+ });
492
+ Object.assign(contents, doc);
493
+ return contents;
374
494
  };
375
- var InstanceStateName = {
376
- PENDING: "PENDING",
377
- RUNNING: "RUNNING",
378
- SHUTTING_DOWN: "SHUTTING_DOWN",
379
- STOPPED: "STOPPED",
380
- STOPPING: "STOPPING",
381
- TERMINATED: "TERMINATED"
495
+ const de_DescribeTaskCommand = async (output, context) => {
496
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
497
+ return de_CommandError(output, context);
498
+ }
499
+ const contents = smithyClient.map({
500
+ $metadata: deserializeMetadata(output),
501
+ });
502
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
503
+ const doc = smithyClient.take(data, {
504
+ completedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
505
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
506
+ description: smithyClient.expectString,
507
+ lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
508
+ state: smithyClient.expectString,
509
+ tags: smithyClient._json,
510
+ targets: smithyClient._json,
511
+ taskArn: smithyClient.expectString,
512
+ taskId: smithyClient.expectString,
513
+ });
514
+ Object.assign(contents, doc);
515
+ return contents;
382
516
  };
383
- var ExecutionState = {
384
- CANCELED: "CANCELED",
385
- FAILED: "FAILED",
386
- IN_PROGRESS: "IN_PROGRESS",
387
- QUEUED: "QUEUED",
388
- REJECTED: "REJECTED",
389
- SUCCEEDED: "SUCCEEDED",
390
- TIMED_OUT: "TIMED_OUT"
517
+ const de_ListDeviceResourcesCommand = async (output, context) => {
518
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
519
+ return de_CommandError(output, context);
520
+ }
521
+ const contents = smithyClient.map({
522
+ $metadata: deserializeMetadata(output),
523
+ });
524
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
525
+ const doc = smithyClient.take(data, {
526
+ nextToken: smithyClient.expectString,
527
+ resources: smithyClient._json,
528
+ });
529
+ Object.assign(contents, doc);
530
+ return contents;
391
531
  };
392
- var TaskState = {
393
- CANCELED: "CANCELED",
394
- COMPLETED: "COMPLETED",
395
- IN_PROGRESS: "IN_PROGRESS"
532
+ const de_ListDevicesCommand = async (output, context) => {
533
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
534
+ return de_CommandError(output, context);
535
+ }
536
+ const contents = smithyClient.map({
537
+ $metadata: deserializeMetadata(output),
538
+ });
539
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
540
+ const doc = smithyClient.take(data, {
541
+ devices: smithyClient._json,
542
+ nextToken: smithyClient.expectString,
543
+ });
544
+ Object.assign(contents, doc);
545
+ return contents;
396
546
  };
397
-
398
- // src/protocols/Aws_restJson1.ts
399
- var se_CancelTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
400
- const b = (0, import_core.requestBuilder)(input, context);
401
- const headers = {};
402
- b.bp("/task/{taskId}/cancel");
403
- b.p("taskId", () => input.taskId, "{taskId}", false);
404
- let body;
405
- b.m("POST").h(headers).b(body);
406
- return b.build();
407
- }, "se_CancelTaskCommand");
408
- var se_CreateTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
409
- const b = (0, import_core.requestBuilder)(input, context);
410
- const headers = {
411
- "content-type": "application/json"
412
- };
413
- b.bp("/task");
414
- let body;
415
- body = JSON.stringify(
416
- (0, import_smithy_client.take)(input, {
417
- clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
418
- command: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "command"),
419
- description: [],
420
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
421
- targets: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "targets")
422
- })
423
- );
424
- b.m("POST").h(headers).b(body);
425
- return b.build();
426
- }, "se_CreateTaskCommand");
427
- var se_DescribeDeviceCommand = /* @__PURE__ */ __name(async (input, context) => {
428
- const b = (0, import_core.requestBuilder)(input, context);
429
- const headers = {};
430
- b.bp("/managed-device/{managedDeviceId}/describe");
431
- b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
432
- let body;
433
- b.m("POST").h(headers).b(body);
434
- return b.build();
435
- }, "se_DescribeDeviceCommand");
436
- var se_DescribeDeviceEc2InstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
437
- const b = (0, import_core.requestBuilder)(input, context);
438
- const headers = {
439
- "content-type": "application/json"
440
- };
441
- b.bp("/managed-device/{managedDeviceId}/resources/ec2/describe");
442
- b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
443
- let body;
444
- body = JSON.stringify(
445
- (0, import_smithy_client.take)(input, {
446
- instanceIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "instanceIds")
447
- })
448
- );
449
- b.m("POST").h(headers).b(body);
450
- return b.build();
451
- }, "se_DescribeDeviceEc2InstancesCommand");
452
- var se_DescribeExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
453
- const b = (0, import_core.requestBuilder)(input, context);
454
- const headers = {};
455
- b.bp("/task/{taskId}/execution/{managedDeviceId}");
456
- b.p("taskId", () => input.taskId, "{taskId}", false);
457
- b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
458
- let body;
459
- b.m("POST").h(headers).b(body);
460
- return b.build();
461
- }, "se_DescribeExecutionCommand");
462
- var se_DescribeTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
463
- const b = (0, import_core.requestBuilder)(input, context);
464
- const headers = {};
465
- b.bp("/task/{taskId}");
466
- b.p("taskId", () => input.taskId, "{taskId}", false);
467
- let body;
468
- b.m("POST").h(headers).b(body);
469
- return b.build();
470
- }, "se_DescribeTaskCommand");
471
- var se_ListDeviceResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
472
- const b = (0, import_core.requestBuilder)(input, context);
473
- const headers = {};
474
- b.bp("/managed-device/{managedDeviceId}/resources");
475
- b.p("managedDeviceId", () => input.managedDeviceId, "{managedDeviceId}", false);
476
- const query = (0, import_smithy_client.map)({
477
- [_t]: [, input[_t]],
478
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
479
- [_nT]: [, input[_nT]]
480
- });
481
- let body;
482
- b.m("GET").h(headers).q(query).b(body);
483
- return b.build();
484
- }, "se_ListDeviceResourcesCommand");
485
- var se_ListDevicesCommand = /* @__PURE__ */ __name(async (input, context) => {
486
- const b = (0, import_core.requestBuilder)(input, context);
487
- const headers = {};
488
- b.bp("/managed-devices");
489
- const query = (0, import_smithy_client.map)({
490
- [_jI]: [, input[_jI]],
491
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
492
- [_nT]: [, input[_nT]]
493
- });
494
- let body;
495
- b.m("GET").h(headers).q(query).b(body);
496
- return b.build();
497
- }, "se_ListDevicesCommand");
498
- var se_ListExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
499
- const b = (0, import_core.requestBuilder)(input, context);
500
- const headers = {};
501
- b.bp("/executions");
502
- const query = (0, import_smithy_client.map)({
503
- [_tI]: [, (0, import_smithy_client.expectNonNull)(input[_tI], `taskId`)],
504
- [_s]: [, input[_s]],
505
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
506
- [_nT]: [, input[_nT]]
507
- });
508
- let body;
509
- b.m("GET").h(headers).q(query).b(body);
510
- return b.build();
511
- }, "se_ListExecutionsCommand");
512
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
513
- const b = (0, import_core.requestBuilder)(input, context);
514
- const headers = {};
515
- b.bp("/tags/{resourceArn}");
516
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
517
- let body;
518
- b.m("GET").h(headers).b(body);
519
- return b.build();
520
- }, "se_ListTagsForResourceCommand");
521
- var se_ListTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
522
- const b = (0, import_core.requestBuilder)(input, context);
523
- const headers = {};
524
- b.bp("/tasks");
525
- const query = (0, import_smithy_client.map)({
526
- [_s]: [, input[_s]],
527
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
528
- [_nT]: [, input[_nT]]
529
- });
530
- let body;
531
- b.m("GET").h(headers).q(query).b(body);
532
- return b.build();
533
- }, "se_ListTasksCommand");
534
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
535
- const b = (0, import_core.requestBuilder)(input, context);
536
- const headers = {
537
- "content-type": "application/json"
538
- };
539
- b.bp("/tags/{resourceArn}");
540
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
541
- let body;
542
- body = JSON.stringify(
543
- (0, import_smithy_client.take)(input, {
544
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
545
- })
546
- );
547
- b.m("POST").h(headers).b(body);
548
- return b.build();
549
- }, "se_TagResourceCommand");
550
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
551
- const b = (0, import_core.requestBuilder)(input, context);
552
- const headers = {};
553
- b.bp("/tags/{resourceArn}");
554
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
555
- const query = (0, import_smithy_client.map)({
556
- [_tK]: [(0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []]
557
- });
558
- let body;
559
- b.m("DELETE").h(headers).q(query).b(body);
560
- return b.build();
561
- }, "se_UntagResourceCommand");
562
- var de_CancelTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
563
- if (output.statusCode !== 200 && output.statusCode >= 300) {
564
- return de_CommandError(output, context);
565
- }
566
- const contents = (0, import_smithy_client.map)({
567
- $metadata: deserializeMetadata(output)
568
- });
569
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
570
- const doc = (0, import_smithy_client.take)(data, {
571
- taskId: import_smithy_client.expectString
572
- });
573
- Object.assign(contents, doc);
574
- return contents;
575
- }, "de_CancelTaskCommand");
576
- var de_CreateTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
577
- if (output.statusCode !== 200 && output.statusCode >= 300) {
578
- return de_CommandError(output, context);
579
- }
580
- const contents = (0, import_smithy_client.map)({
581
- $metadata: deserializeMetadata(output)
582
- });
583
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
584
- const doc = (0, import_smithy_client.take)(data, {
585
- taskArn: import_smithy_client.expectString,
586
- taskId: import_smithy_client.expectString
587
- });
588
- Object.assign(contents, doc);
589
- return contents;
590
- }, "de_CreateTaskCommand");
591
- var de_DescribeDeviceCommand = /* @__PURE__ */ __name(async (output, context) => {
592
- if (output.statusCode !== 200 && output.statusCode >= 300) {
593
- return de_CommandError(output, context);
594
- }
595
- const contents = (0, import_smithy_client.map)({
596
- $metadata: deserializeMetadata(output)
597
- });
598
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
599
- const doc = (0, import_smithy_client.take)(data, {
600
- associatedWithJob: import_smithy_client.expectString,
601
- deviceCapacities: import_smithy_client._json,
602
- deviceState: import_smithy_client.expectString,
603
- deviceType: import_smithy_client.expectString,
604
- lastReachedOutAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastReachedOutAt"),
605
- lastUpdatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdatedAt"),
606
- managedDeviceArn: import_smithy_client.expectString,
607
- managedDeviceId: import_smithy_client.expectString,
608
- physicalNetworkInterfaces: import_smithy_client._json,
609
- software: import_smithy_client._json,
610
- tags: import_smithy_client._json
611
- });
612
- Object.assign(contents, doc);
613
- return contents;
614
- }, "de_DescribeDeviceCommand");
615
- var de_DescribeDeviceEc2InstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
616
- if (output.statusCode !== 200 && output.statusCode >= 300) {
617
- return de_CommandError(output, context);
618
- }
619
- const contents = (0, import_smithy_client.map)({
620
- $metadata: deserializeMetadata(output)
621
- });
622
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
623
- const doc = (0, import_smithy_client.take)(data, {
624
- instances: /* @__PURE__ */ __name((_) => de_InstanceSummaryList(_, context), "instances")
625
- });
626
- Object.assign(contents, doc);
627
- return contents;
628
- }, "de_DescribeDeviceEc2InstancesCommand");
629
- var de_DescribeExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
630
- if (output.statusCode !== 200 && output.statusCode >= 300) {
631
- return de_CommandError(output, context);
632
- }
633
- const contents = (0, import_smithy_client.map)({
634
- $metadata: deserializeMetadata(output)
635
- });
636
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
637
- const doc = (0, import_smithy_client.take)(data, {
638
- executionId: import_smithy_client.expectString,
639
- lastUpdatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdatedAt"),
640
- managedDeviceId: import_smithy_client.expectString,
641
- startedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "startedAt"),
642
- state: import_smithy_client.expectString,
643
- taskId: import_smithy_client.expectString
644
- });
645
- Object.assign(contents, doc);
646
- return contents;
647
- }, "de_DescribeExecutionCommand");
648
- var de_DescribeTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
649
- if (output.statusCode !== 200 && output.statusCode >= 300) {
650
- return de_CommandError(output, context);
651
- }
652
- const contents = (0, import_smithy_client.map)({
653
- $metadata: deserializeMetadata(output)
654
- });
655
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
656
- const doc = (0, import_smithy_client.take)(data, {
657
- completedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "completedAt"),
658
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
659
- description: import_smithy_client.expectString,
660
- lastUpdatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdatedAt"),
661
- state: import_smithy_client.expectString,
662
- tags: import_smithy_client._json,
663
- targets: import_smithy_client._json,
664
- taskArn: import_smithy_client.expectString,
665
- taskId: import_smithy_client.expectString
666
- });
667
- Object.assign(contents, doc);
668
- return contents;
669
- }, "de_DescribeTaskCommand");
670
- var de_ListDeviceResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
671
- if (output.statusCode !== 200 && output.statusCode >= 300) {
672
- return de_CommandError(output, context);
673
- }
674
- const contents = (0, import_smithy_client.map)({
675
- $metadata: deserializeMetadata(output)
676
- });
677
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
678
- const doc = (0, import_smithy_client.take)(data, {
679
- nextToken: import_smithy_client.expectString,
680
- resources: import_smithy_client._json
681
- });
682
- Object.assign(contents, doc);
683
- return contents;
684
- }, "de_ListDeviceResourcesCommand");
685
- var de_ListDevicesCommand = /* @__PURE__ */ __name(async (output, context) => {
686
- if (output.statusCode !== 200 && output.statusCode >= 300) {
687
- return de_CommandError(output, context);
688
- }
689
- const contents = (0, import_smithy_client.map)({
690
- $metadata: deserializeMetadata(output)
691
- });
692
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
693
- const doc = (0, import_smithy_client.take)(data, {
694
- devices: import_smithy_client._json,
695
- nextToken: import_smithy_client.expectString
696
- });
697
- Object.assign(contents, doc);
698
- return contents;
699
- }, "de_ListDevicesCommand");
700
- var de_ListExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
701
- if (output.statusCode !== 200 && output.statusCode >= 300) {
702
- return de_CommandError(output, context);
703
- }
704
- const contents = (0, import_smithy_client.map)({
705
- $metadata: deserializeMetadata(output)
706
- });
707
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
708
- const doc = (0, import_smithy_client.take)(data, {
709
- executions: import_smithy_client._json,
710
- nextToken: import_smithy_client.expectString
711
- });
712
- Object.assign(contents, doc);
713
- return contents;
714
- }, "de_ListExecutionsCommand");
715
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
716
- if (output.statusCode !== 200 && output.statusCode >= 300) {
717
- return de_CommandError(output, context);
718
- }
719
- const contents = (0, import_smithy_client.map)({
720
- $metadata: deserializeMetadata(output)
721
- });
722
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
723
- const doc = (0, import_smithy_client.take)(data, {
724
- tags: import_smithy_client._json
725
- });
726
- Object.assign(contents, doc);
727
- return contents;
728
- }, "de_ListTagsForResourceCommand");
729
- var de_ListTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
730
- if (output.statusCode !== 200 && output.statusCode >= 300) {
731
- return de_CommandError(output, context);
732
- }
733
- const contents = (0, import_smithy_client.map)({
734
- $metadata: deserializeMetadata(output)
735
- });
736
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
737
- const doc = (0, import_smithy_client.take)(data, {
738
- nextToken: import_smithy_client.expectString,
739
- tasks: import_smithy_client._json
740
- });
741
- Object.assign(contents, doc);
742
- return contents;
743
- }, "de_ListTasksCommand");
744
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
745
- if (output.statusCode !== 200 && output.statusCode >= 300) {
746
- return de_CommandError(output, context);
747
- }
748
- const contents = (0, import_smithy_client.map)({
749
- $metadata: deserializeMetadata(output)
750
- });
751
- await (0, import_smithy_client.collectBody)(output.body, context);
752
- return contents;
753
- }, "de_TagResourceCommand");
754
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
755
- if (output.statusCode !== 200 && output.statusCode >= 300) {
756
- return de_CommandError(output, context);
757
- }
758
- const contents = (0, import_smithy_client.map)({
759
- $metadata: deserializeMetadata(output)
760
- });
761
- await (0, import_smithy_client.collectBody)(output.body, context);
762
- return contents;
763
- }, "de_UntagResourceCommand");
764
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
765
- const parsedOutput = {
766
- ...output,
767
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
768
- };
769
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
770
- switch (errorCode) {
771
- case "AccessDeniedException":
772
- case "com.amazonaws.snowdevicemanagement#AccessDeniedException":
773
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
774
- case "InternalServerException":
775
- case "com.amazonaws.snowdevicemanagement#InternalServerException":
776
- throw await de_InternalServerExceptionRes(parsedOutput, context);
777
- case "ResourceNotFoundException":
778
- case "com.amazonaws.snowdevicemanagement#ResourceNotFoundException":
779
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
780
- case "ThrottlingException":
781
- case "com.amazonaws.snowdevicemanagement#ThrottlingException":
782
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
783
- case "ValidationException":
784
- case "com.amazonaws.snowdevicemanagement#ValidationException":
785
- throw await de_ValidationExceptionRes(parsedOutput, context);
786
- case "ServiceQuotaExceededException":
787
- case "com.amazonaws.snowdevicemanagement#ServiceQuotaExceededException":
788
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
789
- default:
790
- const parsedBody = parsedOutput.body;
791
- return throwDefaultError({
792
- output,
793
- parsedBody,
794
- errorCode
795
- });
796
- }
797
- }, "de_CommandError");
798
- var throwDefaultError = (0, import_smithy_client.withBaseException)(SnowDeviceManagementServiceException);
799
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
800
- const contents = (0, import_smithy_client.map)({});
801
- const data = parsedOutput.body;
802
- const doc = (0, import_smithy_client.take)(data, {
803
- message: import_smithy_client.expectString
804
- });
805
- Object.assign(contents, doc);
806
- const exception = new AccessDeniedException({
807
- $metadata: deserializeMetadata(parsedOutput),
808
- ...contents
809
- });
810
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
811
- }, "de_AccessDeniedExceptionRes");
812
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
813
- const contents = (0, import_smithy_client.map)({});
814
- const data = parsedOutput.body;
815
- const doc = (0, import_smithy_client.take)(data, {
816
- message: import_smithy_client.expectString
817
- });
818
- Object.assign(contents, doc);
819
- const exception = new InternalServerException({
820
- $metadata: deserializeMetadata(parsedOutput),
821
- ...contents
822
- });
823
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
824
- }, "de_InternalServerExceptionRes");
825
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
826
- const contents = (0, import_smithy_client.map)({});
827
- const data = parsedOutput.body;
828
- const doc = (0, import_smithy_client.take)(data, {
829
- message: import_smithy_client.expectString
830
- });
831
- Object.assign(contents, doc);
832
- const exception = new ResourceNotFoundException({
833
- $metadata: deserializeMetadata(parsedOutput),
834
- ...contents
835
- });
836
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
837
- }, "de_ResourceNotFoundExceptionRes");
838
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
839
- const contents = (0, import_smithy_client.map)({});
840
- const data = parsedOutput.body;
841
- const doc = (0, import_smithy_client.take)(data, {
842
- message: import_smithy_client.expectString
843
- });
844
- Object.assign(contents, doc);
845
- const exception = new ServiceQuotaExceededException({
846
- $metadata: deserializeMetadata(parsedOutput),
847
- ...contents
848
- });
849
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
850
- }, "de_ServiceQuotaExceededExceptionRes");
851
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
852
- const contents = (0, import_smithy_client.map)({});
853
- const data = parsedOutput.body;
854
- const doc = (0, import_smithy_client.take)(data, {
855
- message: import_smithy_client.expectString
856
- });
857
- Object.assign(contents, doc);
858
- const exception = new ThrottlingException({
859
- $metadata: deserializeMetadata(parsedOutput),
860
- ...contents
861
- });
862
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
863
- }, "de_ThrottlingExceptionRes");
864
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
865
- const contents = (0, import_smithy_client.map)({});
866
- const data = parsedOutput.body;
867
- const doc = (0, import_smithy_client.take)(data, {
868
- message: import_smithy_client.expectString
869
- });
870
- Object.assign(contents, doc);
871
- const exception = new ValidationException({
872
- $metadata: deserializeMetadata(parsedOutput),
873
- ...contents
874
- });
875
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
876
- }, "de_ValidationExceptionRes");
877
- var de_EbsInstanceBlockDevice = /* @__PURE__ */ __name((output, context) => {
878
- return (0, import_smithy_client.take)(output, {
879
- attachTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "attachTime"),
880
- deleteOnTermination: import_smithy_client.expectBoolean,
881
- status: import_smithy_client.expectString,
882
- volumeId: import_smithy_client.expectString
883
- });
884
- }, "de_EbsInstanceBlockDevice");
885
- var de_Instance = /* @__PURE__ */ __name((output, context) => {
886
- return (0, import_smithy_client.take)(output, {
887
- amiLaunchIndex: import_smithy_client.expectInt32,
888
- blockDeviceMappings: /* @__PURE__ */ __name((_) => de_InstanceBlockDeviceMappingList(_, context), "blockDeviceMappings"),
889
- cpuOptions: import_smithy_client._json,
890
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
891
- imageId: import_smithy_client.expectString,
892
- instanceId: import_smithy_client.expectString,
893
- instanceType: import_smithy_client.expectString,
894
- privateIpAddress: import_smithy_client.expectString,
895
- publicIpAddress: import_smithy_client.expectString,
896
- rootDeviceName: import_smithy_client.expectString,
897
- securityGroups: import_smithy_client._json,
898
- state: import_smithy_client._json,
899
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
900
- });
901
- }, "de_Instance");
902
- var de_InstanceBlockDeviceMapping = /* @__PURE__ */ __name((output, context) => {
903
- return (0, import_smithy_client.take)(output, {
904
- deviceName: import_smithy_client.expectString,
905
- ebs: /* @__PURE__ */ __name((_) => de_EbsInstanceBlockDevice(_, context), "ebs")
906
- });
907
- }, "de_InstanceBlockDeviceMapping");
908
- var de_InstanceBlockDeviceMappingList = /* @__PURE__ */ __name((output, context) => {
909
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
910
- return de_InstanceBlockDeviceMapping(entry, context);
911
- });
912
- return retVal;
913
- }, "de_InstanceBlockDeviceMappingList");
914
- var de_InstanceSummary = /* @__PURE__ */ __name((output, context) => {
915
- return (0, import_smithy_client.take)(output, {
916
- instance: /* @__PURE__ */ __name((_) => de_Instance(_, context), "instance"),
917
- lastUpdatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastUpdatedAt")
918
- });
919
- }, "de_InstanceSummary");
920
- var de_InstanceSummaryList = /* @__PURE__ */ __name((output, context) => {
921
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
922
- return de_InstanceSummary(entry, context);
923
- });
924
- return retVal;
925
- }, "de_InstanceSummaryList");
926
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
927
- httpStatusCode: output.statusCode,
928
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
929
- extendedRequestId: output.headers["x-amz-id-2"],
930
- cfId: output.headers["x-amz-cf-id"]
931
- }), "deserializeMetadata");
932
- var _jI = "jobId";
933
- var _mR = "maxResults";
934
- var _nT = "nextToken";
935
- var _s = "state";
936
- var _t = "type";
937
- var _tI = "taskId";
938
- var _tK = "tagKeys";
939
-
940
- // src/commands/CancelTaskCommand.ts
941
- var CancelTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
942
- return [
943
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
944
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
945
- ];
946
- }).s("SnowDeviceManagement", "CancelTask", {}).n("SnowDeviceManagementClient", "CancelTaskCommand").f(void 0, void 0).ser(se_CancelTaskCommand).de(de_CancelTaskCommand).build() {
947
- static {
948
- __name(this, "CancelTaskCommand");
949
- }
547
+ const de_ListExecutionsCommand = async (output, context) => {
548
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
549
+ return de_CommandError(output, context);
550
+ }
551
+ const contents = smithyClient.map({
552
+ $metadata: deserializeMetadata(output),
553
+ });
554
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
555
+ const doc = smithyClient.take(data, {
556
+ executions: smithyClient._json,
557
+ nextToken: smithyClient.expectString,
558
+ });
559
+ Object.assign(contents, doc);
560
+ return contents;
950
561
  };
951
-
952
- // src/commands/CreateTaskCommand.ts
953
-
954
-
955
-
956
- var CreateTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
957
- return [
958
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
959
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
960
- ];
961
- }).s("SnowDeviceManagement", "CreateTask", {}).n("SnowDeviceManagementClient", "CreateTaskCommand").f(void 0, void 0).ser(se_CreateTaskCommand).de(de_CreateTaskCommand).build() {
962
- static {
963
- __name(this, "CreateTaskCommand");
964
- }
562
+ const de_ListTagsForResourceCommand = async (output, context) => {
563
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
564
+ return de_CommandError(output, context);
565
+ }
566
+ const contents = smithyClient.map({
567
+ $metadata: deserializeMetadata(output),
568
+ });
569
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
570
+ const doc = smithyClient.take(data, {
571
+ tags: smithyClient._json,
572
+ });
573
+ Object.assign(contents, doc);
574
+ return contents;
965
575
  };
966
-
967
- // src/commands/DescribeDeviceCommand.ts
968
-
969
-
970
-
971
- var DescribeDeviceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
972
- return [
973
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
974
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
975
- ];
976
- }).s("SnowDeviceManagement", "DescribeDevice", {}).n("SnowDeviceManagementClient", "DescribeDeviceCommand").f(void 0, void 0).ser(se_DescribeDeviceCommand).de(de_DescribeDeviceCommand).build() {
977
- static {
978
- __name(this, "DescribeDeviceCommand");
979
- }
576
+ const de_ListTasksCommand = async (output, context) => {
577
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
578
+ return de_CommandError(output, context);
579
+ }
580
+ const contents = smithyClient.map({
581
+ $metadata: deserializeMetadata(output),
582
+ });
583
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
584
+ const doc = smithyClient.take(data, {
585
+ nextToken: smithyClient.expectString,
586
+ tasks: smithyClient._json,
587
+ });
588
+ Object.assign(contents, doc);
589
+ return contents;
980
590
  };
981
-
982
- // src/commands/DescribeDeviceEc2InstancesCommand.ts
983
-
984
-
985
-
986
- var DescribeDeviceEc2InstancesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
987
- return [
988
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
989
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
990
- ];
991
- }).s("SnowDeviceManagement", "DescribeDeviceEc2Instances", {}).n("SnowDeviceManagementClient", "DescribeDeviceEc2InstancesCommand").f(void 0, void 0).ser(se_DescribeDeviceEc2InstancesCommand).de(de_DescribeDeviceEc2InstancesCommand).build() {
992
- static {
993
- __name(this, "DescribeDeviceEc2InstancesCommand");
994
- }
591
+ const de_TagResourceCommand = async (output, context) => {
592
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
593
+ return de_CommandError(output, context);
594
+ }
595
+ const contents = smithyClient.map({
596
+ $metadata: deserializeMetadata(output),
597
+ });
598
+ await smithyClient.collectBody(output.body, context);
599
+ return contents;
995
600
  };
996
-
997
- // src/commands/DescribeExecutionCommand.ts
998
-
999
-
1000
-
1001
- var DescribeExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1002
- return [
1003
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1004
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1005
- ];
1006
- }).s("SnowDeviceManagement", "DescribeExecution", {}).n("SnowDeviceManagementClient", "DescribeExecutionCommand").f(void 0, void 0).ser(se_DescribeExecutionCommand).de(de_DescribeExecutionCommand).build() {
1007
- static {
1008
- __name(this, "DescribeExecutionCommand");
1009
- }
601
+ const de_UntagResourceCommand = async (output, context) => {
602
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
603
+ return de_CommandError(output, context);
604
+ }
605
+ const contents = smithyClient.map({
606
+ $metadata: deserializeMetadata(output),
607
+ });
608
+ await smithyClient.collectBody(output.body, context);
609
+ return contents;
1010
610
  };
1011
-
1012
- // src/commands/DescribeTaskCommand.ts
1013
-
1014
-
1015
-
1016
- var DescribeTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1017
- return [
1018
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1019
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1020
- ];
1021
- }).s("SnowDeviceManagement", "DescribeTask", {}).n("SnowDeviceManagementClient", "DescribeTaskCommand").f(void 0, void 0).ser(se_DescribeTaskCommand).de(de_DescribeTaskCommand).build() {
1022
- static {
1023
- __name(this, "DescribeTaskCommand");
1024
- }
611
+ const de_CommandError = async (output, context) => {
612
+ const parsedOutput = {
613
+ ...output,
614
+ body: await core$1.parseJsonErrorBody(output.body, context),
615
+ };
616
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
617
+ switch (errorCode) {
618
+ case "AccessDeniedException":
619
+ case "com.amazonaws.snowdevicemanagement#AccessDeniedException":
620
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
621
+ case "InternalServerException":
622
+ case "com.amazonaws.snowdevicemanagement#InternalServerException":
623
+ throw await de_InternalServerExceptionRes(parsedOutput);
624
+ case "ResourceNotFoundException":
625
+ case "com.amazonaws.snowdevicemanagement#ResourceNotFoundException":
626
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
627
+ case "ThrottlingException":
628
+ case "com.amazonaws.snowdevicemanagement#ThrottlingException":
629
+ throw await de_ThrottlingExceptionRes(parsedOutput);
630
+ case "ValidationException":
631
+ case "com.amazonaws.snowdevicemanagement#ValidationException":
632
+ throw await de_ValidationExceptionRes(parsedOutput);
633
+ case "ServiceQuotaExceededException":
634
+ case "com.amazonaws.snowdevicemanagement#ServiceQuotaExceededException":
635
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
636
+ default:
637
+ const parsedBody = parsedOutput.body;
638
+ return throwDefaultError({
639
+ output,
640
+ parsedBody,
641
+ errorCode,
642
+ });
643
+ }
1025
644
  };
1026
-
1027
- // src/commands/ListDeviceResourcesCommand.ts
1028
-
1029
-
1030
-
1031
- var ListDeviceResourcesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1032
- return [
1033
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1034
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1035
- ];
1036
- }).s("SnowDeviceManagement", "ListDeviceResources", {}).n("SnowDeviceManagementClient", "ListDeviceResourcesCommand").f(void 0, void 0).ser(se_ListDeviceResourcesCommand).de(de_ListDeviceResourcesCommand).build() {
1037
- static {
1038
- __name(this, "ListDeviceResourcesCommand");
1039
- }
645
+ const throwDefaultError = smithyClient.withBaseException(SnowDeviceManagementServiceException);
646
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
647
+ const contents = smithyClient.map({});
648
+ const data = parsedOutput.body;
649
+ const doc = smithyClient.take(data, {
650
+ message: smithyClient.expectString,
651
+ });
652
+ Object.assign(contents, doc);
653
+ const exception = new AccessDeniedException({
654
+ $metadata: deserializeMetadata(parsedOutput),
655
+ ...contents,
656
+ });
657
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1040
658
  };
1041
-
1042
- // src/commands/ListDevicesCommand.ts
1043
-
1044
-
1045
-
1046
- var ListDevicesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1047
- return [
1048
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1049
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1050
- ];
1051
- }).s("SnowDeviceManagement", "ListDevices", {}).n("SnowDeviceManagementClient", "ListDevicesCommand").f(void 0, void 0).ser(se_ListDevicesCommand).de(de_ListDevicesCommand).build() {
1052
- static {
1053
- __name(this, "ListDevicesCommand");
1054
- }
659
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
660
+ const contents = smithyClient.map({});
661
+ const data = parsedOutput.body;
662
+ const doc = smithyClient.take(data, {
663
+ message: smithyClient.expectString,
664
+ });
665
+ Object.assign(contents, doc);
666
+ const exception = new InternalServerException({
667
+ $metadata: deserializeMetadata(parsedOutput),
668
+ ...contents,
669
+ });
670
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1055
671
  };
1056
-
1057
- // src/commands/ListExecutionsCommand.ts
1058
-
1059
-
1060
-
1061
- var ListExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1062
- return [
1063
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1064
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1065
- ];
1066
- }).s("SnowDeviceManagement", "ListExecutions", {}).n("SnowDeviceManagementClient", "ListExecutionsCommand").f(void 0, void 0).ser(se_ListExecutionsCommand).de(de_ListExecutionsCommand).build() {
1067
- static {
1068
- __name(this, "ListExecutionsCommand");
1069
- }
672
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
673
+ const contents = smithyClient.map({});
674
+ const data = parsedOutput.body;
675
+ const doc = smithyClient.take(data, {
676
+ message: smithyClient.expectString,
677
+ });
678
+ Object.assign(contents, doc);
679
+ const exception = new ResourceNotFoundException({
680
+ $metadata: deserializeMetadata(parsedOutput),
681
+ ...contents,
682
+ });
683
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1070
684
  };
1071
-
1072
- // src/commands/ListTagsForResourceCommand.ts
1073
-
1074
-
1075
-
1076
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1077
- return [
1078
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1079
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1080
- ];
1081
- }).s("SnowDeviceManagement", "ListTagsForResource", {}).n("SnowDeviceManagementClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1082
- static {
1083
- __name(this, "ListTagsForResourceCommand");
1084
- }
685
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
686
+ const contents = smithyClient.map({});
687
+ const data = parsedOutput.body;
688
+ const doc = smithyClient.take(data, {
689
+ message: smithyClient.expectString,
690
+ });
691
+ Object.assign(contents, doc);
692
+ const exception = new ServiceQuotaExceededException({
693
+ $metadata: deserializeMetadata(parsedOutput),
694
+ ...contents,
695
+ });
696
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1085
697
  };
1086
-
1087
- // src/commands/ListTasksCommand.ts
1088
-
1089
-
1090
-
1091
- var ListTasksCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1092
- return [
1093
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1094
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1095
- ];
1096
- }).s("SnowDeviceManagement", "ListTasks", {}).n("SnowDeviceManagementClient", "ListTasksCommand").f(void 0, void 0).ser(se_ListTasksCommand).de(de_ListTasksCommand).build() {
1097
- static {
1098
- __name(this, "ListTasksCommand");
1099
- }
698
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
699
+ const contents = smithyClient.map({});
700
+ const data = parsedOutput.body;
701
+ const doc = smithyClient.take(data, {
702
+ message: smithyClient.expectString,
703
+ });
704
+ Object.assign(contents, doc);
705
+ const exception = new ThrottlingException({
706
+ $metadata: deserializeMetadata(parsedOutput),
707
+ ...contents,
708
+ });
709
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1100
710
  };
1101
-
1102
- // src/commands/TagResourceCommand.ts
1103
-
1104
-
1105
-
1106
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1107
- return [
1108
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1109
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1110
- ];
1111
- }).s("SnowDeviceManagement", "TagResource", {}).n("SnowDeviceManagementClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1112
- static {
1113
- __name(this, "TagResourceCommand");
1114
- }
711
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
712
+ const contents = smithyClient.map({});
713
+ const data = parsedOutput.body;
714
+ const doc = smithyClient.take(data, {
715
+ message: smithyClient.expectString,
716
+ });
717
+ Object.assign(contents, doc);
718
+ const exception = new ValidationException({
719
+ $metadata: deserializeMetadata(parsedOutput),
720
+ ...contents,
721
+ });
722
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1115
723
  };
1116
-
1117
- // src/commands/UntagResourceCommand.ts
1118
-
1119
-
1120
-
1121
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o) {
1122
- return [
1123
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1124
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command3.getEndpointParameterInstructions())
1125
- ];
1126
- }).s("SnowDeviceManagement", "UntagResource", {}).n("SnowDeviceManagementClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1127
- static {
1128
- __name(this, "UntagResourceCommand");
1129
- }
724
+ const de_EbsInstanceBlockDevice = (output, context) => {
725
+ return smithyClient.take(output, {
726
+ attachTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
727
+ deleteOnTermination: smithyClient.expectBoolean,
728
+ status: smithyClient.expectString,
729
+ volumeId: smithyClient.expectString,
730
+ });
1130
731
  };
1131
-
1132
- // src/SnowDeviceManagement.ts
1133
- var commands = {
1134
- CancelTaskCommand,
1135
- CreateTaskCommand,
1136
- DescribeDeviceCommand,
1137
- DescribeDeviceEc2InstancesCommand,
1138
- DescribeExecutionCommand,
1139
- DescribeTaskCommand,
1140
- ListDeviceResourcesCommand,
1141
- ListDevicesCommand,
1142
- ListExecutionsCommand,
1143
- ListTagsForResourceCommand,
1144
- ListTasksCommand,
1145
- TagResourceCommand,
1146
- UntagResourceCommand
732
+ const de_Instance = (output, context) => {
733
+ return smithyClient.take(output, {
734
+ amiLaunchIndex: smithyClient.expectInt32,
735
+ blockDeviceMappings: (_) => de_InstanceBlockDeviceMappingList(_),
736
+ cpuOptions: smithyClient._json,
737
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
738
+ imageId: smithyClient.expectString,
739
+ instanceId: smithyClient.expectString,
740
+ instanceType: smithyClient.expectString,
741
+ privateIpAddress: smithyClient.expectString,
742
+ publicIpAddress: smithyClient.expectString,
743
+ rootDeviceName: smithyClient.expectString,
744
+ securityGroups: smithyClient._json,
745
+ state: smithyClient._json,
746
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
747
+ });
1147
748
  };
1148
- var SnowDeviceManagement = class extends SnowDeviceManagementClient {
1149
- static {
1150
- __name(this, "SnowDeviceManagement");
1151
- }
749
+ const de_InstanceBlockDeviceMapping = (output, context) => {
750
+ return smithyClient.take(output, {
751
+ deviceName: smithyClient.expectString,
752
+ ebs: (_) => de_EbsInstanceBlockDevice(_),
753
+ });
1152
754
  };
1153
- (0, import_smithy_client.createAggregatedClient)(commands, SnowDeviceManagement);
1154
-
1155
- // src/pagination/ListDeviceResourcesPaginator.ts
1156
-
1157
- var paginateListDeviceResources = (0, import_core.createPaginator)(SnowDeviceManagementClient, ListDeviceResourcesCommand, "nextToken", "nextToken", "maxResults");
1158
-
1159
- // src/pagination/ListDevicesPaginator.ts
1160
-
1161
- var paginateListDevices = (0, import_core.createPaginator)(SnowDeviceManagementClient, ListDevicesCommand, "nextToken", "nextToken", "maxResults");
755
+ const de_InstanceBlockDeviceMappingList = (output, context) => {
756
+ const retVal = (output || [])
757
+ .filter((e) => e != null)
758
+ .map((entry) => {
759
+ return de_InstanceBlockDeviceMapping(entry);
760
+ });
761
+ return retVal;
762
+ };
763
+ const de_InstanceSummary = (output, context) => {
764
+ return smithyClient.take(output, {
765
+ instance: (_) => de_Instance(_),
766
+ lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
767
+ });
768
+ };
769
+ const de_InstanceSummaryList = (output, context) => {
770
+ const retVal = (output || [])
771
+ .filter((e) => e != null)
772
+ .map((entry) => {
773
+ return de_InstanceSummary(entry);
774
+ });
775
+ return retVal;
776
+ };
777
+ const deserializeMetadata = (output) => ({
778
+ httpStatusCode: output.statusCode,
779
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
780
+ extendedRequestId: output.headers["x-amz-id-2"],
781
+ cfId: output.headers["x-amz-cf-id"],
782
+ });
783
+ const _jI = "jobId";
784
+ const _mR = "maxResults";
785
+ const _nT = "nextToken";
786
+ const _s = "state";
787
+ const _t = "type";
788
+ const _tI = "taskId";
789
+ const _tK = "tagKeys";
790
+
791
+ class CancelTaskCommand extends smithyClient.Command
792
+ .classBuilder()
793
+ .ep(commonParams)
794
+ .m(function (Command, cs, config, o) {
795
+ return [
796
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
797
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
798
+ ];
799
+ })
800
+ .s("SnowDeviceManagement", "CancelTask", {})
801
+ .n("SnowDeviceManagementClient", "CancelTaskCommand")
802
+ .f(void 0, void 0)
803
+ .ser(se_CancelTaskCommand)
804
+ .de(de_CancelTaskCommand)
805
+ .build() {
806
+ }
807
+
808
+ class CreateTaskCommand extends smithyClient.Command
809
+ .classBuilder()
810
+ .ep(commonParams)
811
+ .m(function (Command, cs, config, o) {
812
+ return [
813
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
814
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
815
+ ];
816
+ })
817
+ .s("SnowDeviceManagement", "CreateTask", {})
818
+ .n("SnowDeviceManagementClient", "CreateTaskCommand")
819
+ .f(void 0, void 0)
820
+ .ser(se_CreateTaskCommand)
821
+ .de(de_CreateTaskCommand)
822
+ .build() {
823
+ }
824
+
825
+ class DescribeDeviceCommand extends smithyClient.Command
826
+ .classBuilder()
827
+ .ep(commonParams)
828
+ .m(function (Command, cs, config, o) {
829
+ return [
830
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
831
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
832
+ ];
833
+ })
834
+ .s("SnowDeviceManagement", "DescribeDevice", {})
835
+ .n("SnowDeviceManagementClient", "DescribeDeviceCommand")
836
+ .f(void 0, void 0)
837
+ .ser(se_DescribeDeviceCommand)
838
+ .de(de_DescribeDeviceCommand)
839
+ .build() {
840
+ }
841
+
842
+ class DescribeDeviceEc2InstancesCommand extends smithyClient.Command
843
+ .classBuilder()
844
+ .ep(commonParams)
845
+ .m(function (Command, cs, config, o) {
846
+ return [
847
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
848
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
849
+ ];
850
+ })
851
+ .s("SnowDeviceManagement", "DescribeDeviceEc2Instances", {})
852
+ .n("SnowDeviceManagementClient", "DescribeDeviceEc2InstancesCommand")
853
+ .f(void 0, void 0)
854
+ .ser(se_DescribeDeviceEc2InstancesCommand)
855
+ .de(de_DescribeDeviceEc2InstancesCommand)
856
+ .build() {
857
+ }
858
+
859
+ class DescribeExecutionCommand extends smithyClient.Command
860
+ .classBuilder()
861
+ .ep(commonParams)
862
+ .m(function (Command, cs, config, o) {
863
+ return [
864
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
865
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
866
+ ];
867
+ })
868
+ .s("SnowDeviceManagement", "DescribeExecution", {})
869
+ .n("SnowDeviceManagementClient", "DescribeExecutionCommand")
870
+ .f(void 0, void 0)
871
+ .ser(se_DescribeExecutionCommand)
872
+ .de(de_DescribeExecutionCommand)
873
+ .build() {
874
+ }
875
+
876
+ class DescribeTaskCommand extends smithyClient.Command
877
+ .classBuilder()
878
+ .ep(commonParams)
879
+ .m(function (Command, cs, config, o) {
880
+ return [
881
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
882
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
883
+ ];
884
+ })
885
+ .s("SnowDeviceManagement", "DescribeTask", {})
886
+ .n("SnowDeviceManagementClient", "DescribeTaskCommand")
887
+ .f(void 0, void 0)
888
+ .ser(se_DescribeTaskCommand)
889
+ .de(de_DescribeTaskCommand)
890
+ .build() {
891
+ }
892
+
893
+ class ListDeviceResourcesCommand extends smithyClient.Command
894
+ .classBuilder()
895
+ .ep(commonParams)
896
+ .m(function (Command, cs, config, o) {
897
+ return [
898
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
899
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
900
+ ];
901
+ })
902
+ .s("SnowDeviceManagement", "ListDeviceResources", {})
903
+ .n("SnowDeviceManagementClient", "ListDeviceResourcesCommand")
904
+ .f(void 0, void 0)
905
+ .ser(se_ListDeviceResourcesCommand)
906
+ .de(de_ListDeviceResourcesCommand)
907
+ .build() {
908
+ }
909
+
910
+ class ListDevicesCommand extends smithyClient.Command
911
+ .classBuilder()
912
+ .ep(commonParams)
913
+ .m(function (Command, cs, config, o) {
914
+ return [
915
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
916
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
917
+ ];
918
+ })
919
+ .s("SnowDeviceManagement", "ListDevices", {})
920
+ .n("SnowDeviceManagementClient", "ListDevicesCommand")
921
+ .f(void 0, void 0)
922
+ .ser(se_ListDevicesCommand)
923
+ .de(de_ListDevicesCommand)
924
+ .build() {
925
+ }
926
+
927
+ class ListExecutionsCommand extends smithyClient.Command
928
+ .classBuilder()
929
+ .ep(commonParams)
930
+ .m(function (Command, cs, config, o) {
931
+ return [
932
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
933
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
934
+ ];
935
+ })
936
+ .s("SnowDeviceManagement", "ListExecutions", {})
937
+ .n("SnowDeviceManagementClient", "ListExecutionsCommand")
938
+ .f(void 0, void 0)
939
+ .ser(se_ListExecutionsCommand)
940
+ .de(de_ListExecutionsCommand)
941
+ .build() {
942
+ }
943
+
944
+ class ListTagsForResourceCommand extends smithyClient.Command
945
+ .classBuilder()
946
+ .ep(commonParams)
947
+ .m(function (Command, cs, config, o) {
948
+ return [
949
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
950
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
951
+ ];
952
+ })
953
+ .s("SnowDeviceManagement", "ListTagsForResource", {})
954
+ .n("SnowDeviceManagementClient", "ListTagsForResourceCommand")
955
+ .f(void 0, void 0)
956
+ .ser(se_ListTagsForResourceCommand)
957
+ .de(de_ListTagsForResourceCommand)
958
+ .build() {
959
+ }
960
+
961
+ class ListTasksCommand extends smithyClient.Command
962
+ .classBuilder()
963
+ .ep(commonParams)
964
+ .m(function (Command, cs, config, o) {
965
+ return [
966
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
967
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
968
+ ];
969
+ })
970
+ .s("SnowDeviceManagement", "ListTasks", {})
971
+ .n("SnowDeviceManagementClient", "ListTasksCommand")
972
+ .f(void 0, void 0)
973
+ .ser(se_ListTasksCommand)
974
+ .de(de_ListTasksCommand)
975
+ .build() {
976
+ }
977
+
978
+ class TagResourceCommand extends smithyClient.Command
979
+ .classBuilder()
980
+ .ep(commonParams)
981
+ .m(function (Command, cs, config, o) {
982
+ return [
983
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
984
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
985
+ ];
986
+ })
987
+ .s("SnowDeviceManagement", "TagResource", {})
988
+ .n("SnowDeviceManagementClient", "TagResourceCommand")
989
+ .f(void 0, void 0)
990
+ .ser(se_TagResourceCommand)
991
+ .de(de_TagResourceCommand)
992
+ .build() {
993
+ }
994
+
995
+ class UntagResourceCommand extends smithyClient.Command
996
+ .classBuilder()
997
+ .ep(commonParams)
998
+ .m(function (Command, cs, config, o) {
999
+ return [
1000
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1001
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1002
+ ];
1003
+ })
1004
+ .s("SnowDeviceManagement", "UntagResource", {})
1005
+ .n("SnowDeviceManagementClient", "UntagResourceCommand")
1006
+ .f(void 0, void 0)
1007
+ .ser(se_UntagResourceCommand)
1008
+ .de(de_UntagResourceCommand)
1009
+ .build() {
1010
+ }
1011
+
1012
+ const commands = {
1013
+ CancelTaskCommand,
1014
+ CreateTaskCommand,
1015
+ DescribeDeviceCommand,
1016
+ DescribeDeviceEc2InstancesCommand,
1017
+ DescribeExecutionCommand,
1018
+ DescribeTaskCommand,
1019
+ ListDeviceResourcesCommand,
1020
+ ListDevicesCommand,
1021
+ ListExecutionsCommand,
1022
+ ListTagsForResourceCommand,
1023
+ ListTasksCommand,
1024
+ TagResourceCommand,
1025
+ UntagResourceCommand,
1026
+ };
1027
+ class SnowDeviceManagement extends SnowDeviceManagementClient {
1028
+ }
1029
+ smithyClient.createAggregatedClient(commands, SnowDeviceManagement);
1162
1030
 
1163
- // src/pagination/ListExecutionsPaginator.ts
1031
+ const paginateListDeviceResources = core.createPaginator(SnowDeviceManagementClient, ListDeviceResourcesCommand, "nextToken", "nextToken", "maxResults");
1164
1032
 
1165
- var paginateListExecutions = (0, import_core.createPaginator)(SnowDeviceManagementClient, ListExecutionsCommand, "nextToken", "nextToken", "maxResults");
1033
+ const paginateListDevices = core.createPaginator(SnowDeviceManagementClient, ListDevicesCommand, "nextToken", "nextToken", "maxResults");
1166
1034
 
1167
- // src/pagination/ListTasksPaginator.ts
1035
+ const paginateListExecutions = core.createPaginator(SnowDeviceManagementClient, ListExecutionsCommand, "nextToken", "nextToken", "maxResults");
1168
1036
 
1169
- var paginateListTasks = (0, import_core.createPaginator)(SnowDeviceManagementClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
1170
- // Annotate the CommonJS export names for ESM import in node:
1037
+ const paginateListTasks = core.createPaginator(SnowDeviceManagementClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
1171
1038
 
1172
- 0 && (module.exports = {
1173
- SnowDeviceManagementServiceException,
1174
- __Client,
1175
- SnowDeviceManagementClient,
1176
- SnowDeviceManagement,
1177
- $Command,
1178
- CancelTaskCommand,
1179
- CreateTaskCommand,
1180
- DescribeDeviceCommand,
1181
- DescribeDeviceEc2InstancesCommand,
1182
- DescribeExecutionCommand,
1183
- DescribeTaskCommand,
1184
- ListDeviceResourcesCommand,
1185
- ListDevicesCommand,
1186
- ListExecutionsCommand,
1187
- ListTagsForResourceCommand,
1188
- ListTasksCommand,
1189
- TagResourceCommand,
1190
- UntagResourceCommand,
1191
- paginateListDeviceResources,
1192
- paginateListDevices,
1193
- paginateListExecutions,
1194
- paginateListTasks,
1195
- AccessDeniedException,
1196
- AttachmentStatus,
1197
- InternalServerException,
1198
- ResourceNotFoundException,
1199
- ThrottlingException,
1200
- ValidationException,
1201
- Command,
1202
- ServiceQuotaExceededException,
1203
- UnlockState,
1204
- IpAddressAssignment,
1205
- PhysicalConnectorType,
1206
- InstanceStateName,
1207
- ExecutionState,
1208
- TaskState
1039
+ Object.defineProperty(exports, "$Command", {
1040
+ enumerable: true,
1041
+ get: function () { return smithyClient.Command; }
1209
1042
  });
1210
-
1043
+ Object.defineProperty(exports, "__Client", {
1044
+ enumerable: true,
1045
+ get: function () { return smithyClient.Client; }
1046
+ });
1047
+ exports.AccessDeniedException = AccessDeniedException;
1048
+ exports.AttachmentStatus = AttachmentStatus;
1049
+ exports.CancelTaskCommand = CancelTaskCommand;
1050
+ exports.CreateTaskCommand = CreateTaskCommand;
1051
+ exports.DescribeDeviceCommand = DescribeDeviceCommand;
1052
+ exports.DescribeDeviceEc2InstancesCommand = DescribeDeviceEc2InstancesCommand;
1053
+ exports.DescribeExecutionCommand = DescribeExecutionCommand;
1054
+ exports.DescribeTaskCommand = DescribeTaskCommand;
1055
+ exports.ExecutionState = ExecutionState;
1056
+ exports.InstanceStateName = InstanceStateName;
1057
+ exports.InternalServerException = InternalServerException;
1058
+ exports.IpAddressAssignment = IpAddressAssignment;
1059
+ exports.ListDeviceResourcesCommand = ListDeviceResourcesCommand;
1060
+ exports.ListDevicesCommand = ListDevicesCommand;
1061
+ exports.ListExecutionsCommand = ListExecutionsCommand;
1062
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1063
+ exports.ListTasksCommand = ListTasksCommand;
1064
+ exports.PhysicalConnectorType = PhysicalConnectorType;
1065
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1066
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1067
+ exports.SnowDeviceManagement = SnowDeviceManagement;
1068
+ exports.SnowDeviceManagementClient = SnowDeviceManagementClient;
1069
+ exports.SnowDeviceManagementServiceException = SnowDeviceManagementServiceException;
1070
+ exports.TagResourceCommand = TagResourceCommand;
1071
+ exports.TaskState = TaskState;
1072
+ exports.ThrottlingException = ThrottlingException;
1073
+ exports.UnlockState = UnlockState;
1074
+ exports.UntagResourceCommand = UntagResourceCommand;
1075
+ exports.ValidationException = ValidationException;
1076
+ exports.paginateListDeviceResources = paginateListDeviceResources;
1077
+ exports.paginateListDevices = paginateListDevices;
1078
+ exports.paginateListExecutions = paginateListExecutions;
1079
+ exports.paginateListTasks = paginateListTasks;