@aws-sdk/client-device-farm 3.34.0 → 3.35.0

package/src/commands/ListTestsCommand.ts

@@ -0,0 +1,92 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ListTestsRequest, ListTestsResult } from "../models/models_0";
+import { deserializeAws_json1_1ListTestsCommand, serializeAws_json1_1ListTestsCommand } from "../protocols/Aws_json1_1";
+
+export interface ListTestsCommandInput extends ListTestsRequest {}
+export interface ListTestsCommandOutput extends ListTestsResult, __MetadataBearer {}
+
+/**
+ * <p>Gets information about tests in a given test suite.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListTestsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListTestsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListTestsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTestsCommandInput} for command's `input` shape.
+ * @see {@link ListTestsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListTestsCommand extends $Command<
+  ListTestsCommandInput,
+  ListTestsCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListTestsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListTestsCommandInput, ListTestsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "ListTestsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListTestsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListTestsResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListTestsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ListTestsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListTestsCommandOutput> {
+    return deserializeAws_json1_1ListTestsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListUniqueProblemsCommand.ts

@@ -0,0 +1,99 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ListUniqueProblemsRequest, ListUniqueProblemsResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1ListUniqueProblemsCommand,
+  serializeAws_json1_1ListUniqueProblemsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ListUniqueProblemsCommandInput extends ListUniqueProblemsRequest {}
+export interface ListUniqueProblemsCommandOutput extends ListUniqueProblemsResult, __MetadataBearer {}
+
+/**
+ * <p>Gets information about unique problems, such as exceptions or crashes.</p>
+ *         <p>Unique problems are defined as a single instance of an error across a run, job, or suite. For example,
+ *             if a call in your application consistently raises an exception (<code>OutOfBoundsException in
+ *                 MyActivity.java:386</code>), <code>ListUniqueProblems</code> returns a single entry instead of many
+ *             individual entries for that exception.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListUniqueProblemsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListUniqueProblemsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListUniqueProblemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUniqueProblemsCommandInput} for command's `input` shape.
+ * @see {@link ListUniqueProblemsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListUniqueProblemsCommand extends $Command<
+  ListUniqueProblemsCommandInput,
+  ListUniqueProblemsCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListUniqueProblemsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListUniqueProblemsCommandInput, ListUniqueProblemsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "ListUniqueProblemsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListUniqueProblemsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListUniqueProblemsResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListUniqueProblemsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ListUniqueProblemsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListUniqueProblemsCommandOutput> {
+    return deserializeAws_json1_1ListUniqueProblemsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListUploadsCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ListUploadsRequest, ListUploadsResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1ListUploadsCommand,
+  serializeAws_json1_1ListUploadsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ListUploadsCommandInput extends ListUploadsRequest {}
+export interface ListUploadsCommandOutput extends ListUploadsResult, __MetadataBearer {}
+
+/**
+ * <p>Gets information about uploads, given an AWS Device Farm project ARN.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListUploadsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListUploadsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListUploadsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUploadsCommandInput} for command's `input` shape.
+ * @see {@link ListUploadsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListUploadsCommand extends $Command<
+  ListUploadsCommandInput,
+  ListUploadsCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListUploadsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListUploadsCommandInput, ListUploadsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "ListUploadsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListUploadsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListUploadsResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListUploadsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ListUploadsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListUploadsCommandOutput> {
+    return deserializeAws_json1_1ListUploadsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListVPCEConfigurationsCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ListVPCEConfigurationsRequest, ListVPCEConfigurationsResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1ListVPCEConfigurationsCommand,
+  serializeAws_json1_1ListVPCEConfigurationsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ListVPCEConfigurationsCommandInput extends ListVPCEConfigurationsRequest {}
+export interface ListVPCEConfigurationsCommandOutput extends ListVPCEConfigurationsResult, __MetadataBearer {}
+
+/**
+ * <p>Returns information about all Amazon Virtual Private Cloud (VPC) endpoint
+ *             configurations in the AWS account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListVPCEConfigurationsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListVPCEConfigurationsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListVPCEConfigurationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVPCEConfigurationsCommandInput} for command's `input` shape.
+ * @see {@link ListVPCEConfigurationsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListVPCEConfigurationsCommand extends $Command<
+  ListVPCEConfigurationsCommandInput,
+  ListVPCEConfigurationsCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListVPCEConfigurationsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListVPCEConfigurationsCommandInput, ListVPCEConfigurationsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "ListVPCEConfigurationsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListVPCEConfigurationsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListVPCEConfigurationsResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListVPCEConfigurationsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ListVPCEConfigurationsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListVPCEConfigurationsCommandOutput> {
+    return deserializeAws_json1_1ListVPCEConfigurationsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PurchaseOfferingCommand.ts

@@ -0,0 +1,98 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { PurchaseOfferingRequest, PurchaseOfferingResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1PurchaseOfferingCommand,
+  serializeAws_json1_1PurchaseOfferingCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PurchaseOfferingCommandInput extends PurchaseOfferingRequest {}
+export interface PurchaseOfferingCommandOutput extends PurchaseOfferingResult, __MetadataBearer {}
+
+/**
+ * <p>Immediately purchases offerings for an AWS account. Offerings renew with the latest total purchased
+ *             quantity for an offering, unless the renewal was overridden. The API returns a <code>NotEligible</code>
+ *             error if the user is not permitted to invoke the operation. If you must be able to invoke this operation,
+ *             contact <a href="mailto:aws-devicefarm-support@amazon.com">aws-devicefarm-support@amazon.com</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, PurchaseOfferingCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, PurchaseOfferingCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new PurchaseOfferingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PurchaseOfferingCommandInput} for command's `input` shape.
+ * @see {@link PurchaseOfferingCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PurchaseOfferingCommand extends $Command<
+  PurchaseOfferingCommandInput,
+  PurchaseOfferingCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PurchaseOfferingCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PurchaseOfferingCommandInput, PurchaseOfferingCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "PurchaseOfferingCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PurchaseOfferingRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PurchaseOfferingResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PurchaseOfferingCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PurchaseOfferingCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PurchaseOfferingCommandOutput> {
+    return deserializeAws_json1_1PurchaseOfferingCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/RenewOfferingCommand.ts

@@ -0,0 +1,97 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { RenewOfferingRequest, RenewOfferingResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1RenewOfferingCommand,
+  serializeAws_json1_1RenewOfferingCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface RenewOfferingCommandInput extends RenewOfferingRequest {}
+export interface RenewOfferingCommandOutput extends RenewOfferingResult, __MetadataBearer {}
+
+/**
+ * <p>Explicitly sets the quantity of devices to renew for an offering, starting from the
+ *                 <code>effectiveDate</code> of the next period. The API returns a <code>NotEligible</code> error if the
+ *             user is not permitted to invoke the operation. If you must be able to invoke this operation, contact <a href="mailto:aws-devicefarm-support@amazon.com">aws-devicefarm-support@amazon.com</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, RenewOfferingCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, RenewOfferingCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new RenewOfferingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RenewOfferingCommandInput} for command's `input` shape.
+ * @see {@link RenewOfferingCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class RenewOfferingCommand extends $Command<
+  RenewOfferingCommandInput,
+  RenewOfferingCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: RenewOfferingCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<RenewOfferingCommandInput, RenewOfferingCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "RenewOfferingCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: RenewOfferingRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: RenewOfferingResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: RenewOfferingCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1RenewOfferingCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<RenewOfferingCommandOutput> {
+    return deserializeAws_json1_1RenewOfferingCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ScheduleRunCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ScheduleRunRequest, ScheduleRunResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1ScheduleRunCommand,
+  serializeAws_json1_1ScheduleRunCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ScheduleRunCommandInput extends ScheduleRunRequest {}
+export interface ScheduleRunCommandOutput extends ScheduleRunResult, __MetadataBearer {}
+
+/**
+ * <p>Schedules a run.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ScheduleRunCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ScheduleRunCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ScheduleRunCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ScheduleRunCommandInput} for command's `input` shape.
+ * @see {@link ScheduleRunCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ScheduleRunCommand extends $Command<
+  ScheduleRunCommandInput,
+  ScheduleRunCommandOutput,
+  DeviceFarmClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ScheduleRunCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DeviceFarmClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ScheduleRunCommandInput, ScheduleRunCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DeviceFarmClient";
+    const commandName = "ScheduleRunCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ScheduleRunRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ScheduleRunResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ScheduleRunCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ScheduleRunCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ScheduleRunCommandOutput> {
+    return deserializeAws_json1_1ScheduleRunCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}