@aws-sdk/client-device-farm 3.32.0 → 3.36.0

package/dist-cjs/DeviceFarmClient.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceFarmClient = void 0;
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const middleware_content_length_1 = require("@aws-sdk/middleware-content-length");
+const middleware_host_header_1 = require("@aws-sdk/middleware-host-header");
+const middleware_logger_1 = require("@aws-sdk/middleware-logger");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+const middleware_signing_1 = require("@aws-sdk/middleware-signing");
+const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const runtimeConfig_1 = require("./runtimeConfig");
+/**
+ * <p>Welcome to the AWS Device Farm API documentation, which contains APIs for:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>Testing on desktop browsers</p>
+ *                 <p> Device Farm makes it possible for you to test your web applications on desktop browsers using
+ *                     Selenium. The APIs for desktop browser testing contain <code>TestGrid</code> in their names. For
+ *                     more information, see <a href="https://docs.aws.amazon.com/devicefarm/latest/testgrid/">Testing Web
+ *                         Applications on Selenium with Device Farm</a>.</p>
+ *             </li>
+ *             <li>
+ *                 <p>Testing on real mobile devices</p>
+ *                 <p>Device Farm makes it possible for you to test apps on physical phones, tablets, and other
+ *                     devices in the cloud. For more information, see the <a href="https://docs.aws.amazon.com/devicefarm/latest/developerguide/">Device Farm Developer Guide</a>.</p>
+ *             </li>
+ *          </ul>
+ */
+class DeviceFarmClient extends smithy_client_1.Client {
+    constructor(configuration) {
+        const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
+        const _config_1 = config_resolver_1.resolveRegionConfig(_config_0);
+        const _config_2 = config_resolver_1.resolveEndpointsConfig(_config_1);
+        const _config_3 = middleware_retry_1.resolveRetryConfig(_config_2);
+        const _config_4 = middleware_host_header_1.resolveHostHeaderConfig(_config_3);
+        const _config_5 = middleware_signing_1.resolveAwsAuthConfig(_config_4);
+        const _config_6 = middleware_user_agent_1.resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(middleware_retry_1.getRetryPlugin(this.config));
+        this.middlewareStack.use(middleware_content_length_1.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middleware_host_header_1.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middleware_logger_1.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middleware_signing_1.getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(middleware_user_agent_1.getUserAgentPlugin(this.config));
+    }
+    /**
+     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+     */
+    destroy() {
+        super.destroy();
+    }
+}
+exports.DeviceFarmClient = DeviceFarmClient;

package/dist-cjs/commands/CreateDevicePoolCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDevicePoolCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a device pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateDevicePoolCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateDevicePoolCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateDevicePoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDevicePoolCommandInput} for command's `input` shape.
+ * @see {@link CreateDevicePoolCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateDevicePoolCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateDevicePoolRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDevicePoolResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateDevicePoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateDevicePoolCommand(output, context);
+    }
+}
+exports.CreateDevicePoolCommand = CreateDevicePoolCommand;

package/dist-cjs/commands/CreateInstanceProfileCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateInstanceProfileCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a profile that can be applied to one or more private fleet device
+ *             instances.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateInstanceProfileCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateInstanceProfileCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateInstanceProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateInstanceProfileCommandInput} for command's `input` shape.
+ * @see {@link CreateInstanceProfileCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateInstanceProfileCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateInstanceProfileRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateInstanceProfileResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateInstanceProfileCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateInstanceProfileCommand(output, context);
+    }
+}
+exports.CreateInstanceProfileCommand = CreateInstanceProfileCommand;

package/dist-cjs/commands/CreateNetworkProfileCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateNetworkProfileCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a network profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateNetworkProfileCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateNetworkProfileCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateNetworkProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateNetworkProfileCommandInput} for command's `input` shape.
+ * @see {@link CreateNetworkProfileCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateNetworkProfileCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateNetworkProfileRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateNetworkProfileResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateNetworkProfileCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateNetworkProfileCommand(output, context);
+    }
+}
+exports.CreateNetworkProfileCommand = CreateNetworkProfileCommand;

package/dist-cjs/commands/CreateProjectCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateProjectCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a project.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateProjectCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateProjectCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateProjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateProjectCommandInput} for command's `input` shape.
+ * @see {@link CreateProjectCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateProjectCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateProjectRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateProjectResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateProjectCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateProjectCommand(output, context);
+    }
+}
+exports.CreateProjectCommand = CreateProjectCommand;

package/dist-cjs/commands/CreateRemoteAccessSessionCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRemoteAccessSessionCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Specifies and starts a remote access session.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateRemoteAccessSessionCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateRemoteAccessSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRemoteAccessSessionCommandInput} for command's `input` shape.
+ * @see {@link CreateRemoteAccessSessionCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRemoteAccessSessionCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateRemoteAccessSessionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRemoteAccessSessionResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRemoteAccessSessionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRemoteAccessSessionCommand(output, context);
+    }
+}
+exports.CreateRemoteAccessSessionCommand = CreateRemoteAccessSessionCommand;

package/dist-cjs/commands/CreateTestGridProjectCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTestGridProjectCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a Selenium testing project. Projects are used to track <a>TestGridSession</a>
+ *          instances.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateTestGridProjectCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateTestGridProjectCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateTestGridProjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTestGridProjectCommandInput} for command's `input` shape.
+ * @see {@link CreateTestGridProjectCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateTestGridProjectCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateTestGridProjectRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateTestGridProjectResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateTestGridProjectCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateTestGridProjectCommand(output, context);
+    }
+}
+exports.CreateTestGridProjectCommand = CreateTestGridProjectCommand;

package/dist-cjs/commands/CreateTestGridUrlCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTestGridUrlCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a signed, short-term URL that can be passed to a Selenium <code>RemoteWebDriver</code>
+ *          constructor.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateTestGridUrlCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateTestGridUrlCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateTestGridUrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTestGridUrlCommandInput} for command's `input` shape.
+ * @see {@link CreateTestGridUrlCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateTestGridUrlCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateTestGridUrlRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateTestGridUrlResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateTestGridUrlCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateTestGridUrlCommand(output, context);
+    }
+}
+exports.CreateTestGridUrlCommand = CreateTestGridUrlCommand;

package/dist-cjs/commands/CreateUploadCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateUploadCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Uploads an app or test scripts.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateUploadCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateUploadCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateUploadCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateUploadCommandInput} for command's `input` shape.
+ * @see {@link CreateUploadCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateUploadCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateUploadRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateUploadResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateUploadCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateUploadCommand(output, context);
+    }
+}
+exports.CreateUploadCommand = CreateUploadCommand;

package/dist-cjs/commands/CreateVPCEConfigurationCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateVPCEConfigurationCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a configuration record in Device Farm for your Amazon Virtual Private Cloud
+ *             (VPC) endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, CreateVPCEConfigurationCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, CreateVPCEConfigurationCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new CreateVPCEConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateVPCEConfigurationCommandInput} for command's `input` shape.
+ * @see {@link CreateVPCEConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateVPCEConfigurationCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.CreateVPCEConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateVPCEConfigurationResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateVPCEConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateVPCEConfigurationCommand(output, context);
+    }
+}
+exports.CreateVPCEConfigurationCommand = CreateVPCEConfigurationCommand;