@aws-sdk/client-device-farm 3.183.0 → 3.185.0

package/dist-es/DeviceFarmClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,26 +9,31 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class DeviceFarmClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        super(_config_6);
-        this.config = _config_6;
-        this.middlewareStack.use(getRetryPlugin(this.config));
-        this.middlewareStack.use(getContentLengthPlugin(this.config));
-        this.middlewareStack.use(getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(getLoggerPlugin(this.config));
-        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+var DeviceFarmClient = (function (_super) {
+    __extends(DeviceFarmClient, _super);
+    function DeviceFarmClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    DeviceFarmClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return DeviceFarmClient;
+}(__Client));
+export { DeviceFarmClient };

package/dist-es/commands/CreateDevicePoolCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateDevicePoolRequestFilterSensitiveLog, CreateDevicePoolResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDevicePoolCommand, serializeAws_json1_1CreateDevicePoolCommand, } from "../protocols/Aws_json1_1";
-export class CreateDevicePoolCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDevicePoolCommand = (function (_super) {
+    __extends(CreateDevicePoolCommand, _super);
+    function CreateDevicePoolCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDevicePoolCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateDevicePoolCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateDevicePoolCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDevicePoolRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDevicePoolResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDevicePoolCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDevicePoolCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDevicePoolCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDevicePoolCommand(output, context);
-    }
-}
+    };
+    return CreateDevicePoolCommand;
+}($Command));
+export { CreateDevicePoolCommand };

package/dist-es/commands/CreateInstanceProfileCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateInstanceProfileRequestFilterSensitiveLog, CreateInstanceProfileResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateInstanceProfileCommand, serializeAws_json1_1CreateInstanceProfileCommand, } from "../protocols/Aws_json1_1";
-export class CreateInstanceProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateInstanceProfileCommand = (function (_super) {
+    __extends(CreateInstanceProfileCommand, _super);
+    function CreateInstanceProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateInstanceProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateInstanceProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateInstanceProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateInstanceProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateInstanceProfileResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateInstanceProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateInstanceProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateInstanceProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateInstanceProfileCommand(output, context);
-    }
-}
+    };
+    return CreateInstanceProfileCommand;
+}($Command));
+export { CreateInstanceProfileCommand };

package/dist-es/commands/CreateNetworkProfileCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateNetworkProfileRequestFilterSensitiveLog, CreateNetworkProfileResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateNetworkProfileCommand, serializeAws_json1_1CreateNetworkProfileCommand, } from "../protocols/Aws_json1_1";
-export class CreateNetworkProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateNetworkProfileCommand = (function (_super) {
+    __extends(CreateNetworkProfileCommand, _super);
+    function CreateNetworkProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateNetworkProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateNetworkProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateNetworkProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateNetworkProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateNetworkProfileResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateNetworkProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateNetworkProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateNetworkProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateNetworkProfileCommand(output, context);
-    }
-}
+    };
+    return CreateNetworkProfileCommand;
+}($Command));
+export { CreateNetworkProfileCommand };

package/dist-es/commands/CreateProjectCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateProjectRequestFilterSensitiveLog, CreateProjectResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateProjectCommand, serializeAws_json1_1CreateProjectCommand, } from "../protocols/Aws_json1_1";
-export class CreateProjectCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateProjectCommand = (function (_super) {
+    __extends(CreateProjectCommand, _super);
+    function CreateProjectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateProjectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateProjectCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateProjectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateProjectRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateProjectResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateProjectCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateProjectCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateProjectCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateProjectCommand(output, context);
-    }
-}
+    };
+    return CreateProjectCommand;
+}($Command));
+export { CreateProjectCommand };

package/dist-es/commands/CreateRemoteAccessSessionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateRemoteAccessSessionRequestFilterSensitiveLog, CreateRemoteAccessSessionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateRemoteAccessSessionCommand, serializeAws_json1_1CreateRemoteAccessSessionCommand, } from "../protocols/Aws_json1_1";
-export class CreateRemoteAccessSessionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateRemoteAccessSessionCommand = (function (_super) {
+    __extends(CreateRemoteAccessSessionCommand, _super);
+    function CreateRemoteAccessSessionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateRemoteAccessSessionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateRemoteAccessSessionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateRemoteAccessSessionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateRemoteAccessSessionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateRemoteAccessSessionResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRemoteAccessSessionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateRemoteAccessSessionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateRemoteAccessSessionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateRemoteAccessSessionCommand(output, context);
-    }
-}
+    };
+    return CreateRemoteAccessSessionCommand;
+}($Command));
+export { CreateRemoteAccessSessionCommand };

package/dist-es/commands/CreateTestGridProjectCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateTestGridProjectRequestFilterSensitiveLog, CreateTestGridProjectResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateTestGridProjectCommand, serializeAws_json1_1CreateTestGridProjectCommand, } from "../protocols/Aws_json1_1";
-export class CreateTestGridProjectCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTestGridProjectCommand = (function (_super) {
+    __extends(CreateTestGridProjectCommand, _super);
+    function CreateTestGridProjectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTestGridProjectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateTestGridProjectCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateTestGridProjectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTestGridProjectRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTestGridProjectResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTestGridProjectCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateTestGridProjectCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTestGridProjectCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateTestGridProjectCommand(output, context);
-    }
-}
+    };
+    return CreateTestGridProjectCommand;
+}($Command));
+export { CreateTestGridProjectCommand };

package/dist-es/commands/CreateTestGridUrlCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateTestGridUrlRequestFilterSensitiveLog, CreateTestGridUrlResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateTestGridUrlCommand, serializeAws_json1_1CreateTestGridUrlCommand, } from "../protocols/Aws_json1_1";
-export class CreateTestGridUrlCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTestGridUrlCommand = (function (_super) {
+    __extends(CreateTestGridUrlCommand, _super);
+    function CreateTestGridUrlCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTestGridUrlCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateTestGridUrlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateTestGridUrlCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTestGridUrlRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTestGridUrlResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTestGridUrlCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateTestGridUrlCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTestGridUrlCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateTestGridUrlCommand(output, context);
-    }
-}
+    };
+    return CreateTestGridUrlCommand;
+}($Command));
+export { CreateTestGridUrlCommand };

package/dist-es/commands/CreateUploadCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateUploadRequestFilterSensitiveLog, CreateUploadResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateUploadCommand, serializeAws_json1_1CreateUploadCommand, } from "../protocols/Aws_json1_1";
-export class CreateUploadCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateUploadCommand = (function (_super) {
+    __extends(CreateUploadCommand, _super);
+    function CreateUploadCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateUploadCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateUploadCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateUploadCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateUploadRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateUploadResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUploadCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateUploadCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateUploadCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateUploadCommand(output, context);
-    }
-}
+    };
+    return CreateUploadCommand;
+}($Command));
+export { CreateUploadCommand };

package/dist-es/commands/CreateVPCEConfigurationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateVPCEConfigurationRequestFilterSensitiveLog, CreateVPCEConfigurationResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateVPCEConfigurationCommand, serializeAws_json1_1CreateVPCEConfigurationCommand, } from "../protocols/Aws_json1_1";
-export class CreateVPCEConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateVPCEConfigurationCommand = (function (_super) {
+    __extends(CreateVPCEConfigurationCommand, _super);
+    function CreateVPCEConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateVPCEConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DeviceFarmClient";
-        const commandName = "CreateVPCEConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DeviceFarmClient";
+        var commandName = "CreateVPCEConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateVPCEConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateVPCEConfigurationResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVPCEConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateVPCEConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateVPCEConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateVPCEConfigurationCommand(output, context);
-    }
-}
+    };
+    return CreateVPCEConfigurationCommand;
+}($Command));
+export { CreateVPCEConfigurationCommand };