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

package/dist-types/ts3.4/commands/RenewOfferingCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { RenewOfferingRequest, RenewOfferingResult } from "../models/models_0";
+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 declare class RenewOfferingCommand extends $Command<RenewOfferingCommandInput, RenewOfferingCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: RenewOfferingCommandInput;
+    constructor(input: RenewOfferingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RenewOfferingCommandInput, RenewOfferingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ScheduleRunCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { ScheduleRunRequest, ScheduleRunResult } from "../models/models_0";
+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 declare class ScheduleRunCommand extends $Command<ScheduleRunCommandInput, ScheduleRunCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ScheduleRunCommandInput;
+    constructor(input: ScheduleRunCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ScheduleRunCommandInput, ScheduleRunCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/StopJobCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { StopJobRequest, StopJobResult } from "../models/models_0";
+export interface StopJobCommandInput extends StopJobRequest {
+}
+export interface StopJobCommandOutput extends StopJobResult, __MetadataBearer {
+}
+/**
+ * <p>Initiates a stop request for the current job. AWS Device Farm immediately stops the job on the device
+ *             where tests have not started. You are not billed for this device. On the device where tests have started,
+ *             setup suite and teardown suite tests run to completion on the device. You are billed for setup, teardown,
+ *             and any tests that were in progress or already completed.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, StopJobCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, StopJobCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new StopJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopJobCommandInput} for command's `input` shape.
+ * @see {@link StopJobCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopJobCommand extends $Command<StopJobCommandInput, StopJobCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: StopJobCommandInput;
+    constructor(input: StopJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopJobCommandInput, StopJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/StopRemoteAccessSessionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { StopRemoteAccessSessionRequest, StopRemoteAccessSessionResult } from "../models/models_0";
+export interface StopRemoteAccessSessionCommandInput extends StopRemoteAccessSessionRequest {
+}
+export interface StopRemoteAccessSessionCommandOutput extends StopRemoteAccessSessionResult, __MetadataBearer {
+}
+/**
+ * <p>Ends a specified remote access session.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, StopRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, StopRemoteAccessSessionCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new StopRemoteAccessSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopRemoteAccessSessionCommandInput} for command's `input` shape.
+ * @see {@link StopRemoteAccessSessionCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopRemoteAccessSessionCommand extends $Command<StopRemoteAccessSessionCommandInput, StopRemoteAccessSessionCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: StopRemoteAccessSessionCommandInput;
+    constructor(input: StopRemoteAccessSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopRemoteAccessSessionCommandInput, StopRemoteAccessSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/StopRunCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { StopRunRequest, StopRunResult } from "../models/models_0";
+export interface StopRunCommandInput extends StopRunRequest {
+}
+export interface StopRunCommandOutput extends StopRunResult, __MetadataBearer {
+}
+/**
+ * <p>Initiates a stop request for the current test run. AWS Device Farm immediately stops the run on devices
+ *             where tests have not started. You are not billed for these devices. On devices where tests have started
+ *             executing, setup suite and teardown suite tests run to completion on those devices. You are billed for
+ *             setup, teardown, and any tests that were in progress or already completed.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, StopRunCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, StopRunCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new StopRunCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopRunCommandInput} for command's `input` shape.
+ * @see {@link StopRunCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopRunCommand extends $Command<StopRunCommandInput, StopRunCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: StopRunCommandInput;
+    constructor(input: StopRunCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopRunCommandInput, StopRunCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Associates the specified tags to a resource with the specified <code>resourceArn</code>. If existing tags
+ *             on a resource are not specified in the request parameters, they are not changed. When a resource is deleted,
+ *             the tags associated with that resource are also deleted.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, TagResourceCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, TagResourceCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified tags from a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UntagResourceCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UntagResourceCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateDeviceInstanceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateDeviceInstanceRequest, UpdateDeviceInstanceResult } from "../models/models_0";
+export interface UpdateDeviceInstanceCommandInput extends UpdateDeviceInstanceRequest {
+}
+export interface UpdateDeviceInstanceCommandOutput extends UpdateDeviceInstanceResult, __MetadataBearer {
+}
+/**
+ * <p>Updates information about a private device instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateDeviceInstanceCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateDeviceInstanceCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateDeviceInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDeviceInstanceCommandInput} for command's `input` shape.
+ * @see {@link UpdateDeviceInstanceCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateDeviceInstanceCommand extends $Command<UpdateDeviceInstanceCommandInput, UpdateDeviceInstanceCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateDeviceInstanceCommandInput;
+    constructor(input: UpdateDeviceInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDeviceInstanceCommandInput, UpdateDeviceInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateDevicePoolCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateDevicePoolRequest, UpdateDevicePoolResult } from "../models/models_0";
+export interface UpdateDevicePoolCommandInput extends UpdateDevicePoolRequest {
+}
+export interface UpdateDevicePoolCommandOutput extends UpdateDevicePoolResult, __MetadataBearer {
+}
+/**
+ * <p>Modifies the name, description, and rules in a device pool given the attributes and
+ *             the pool ARN. Rule updates are all-or-nothing, meaning they can only be updated as a
+ *             whole (or not at all).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateDevicePoolCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateDevicePoolCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateDevicePoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDevicePoolCommandInput} for command's `input` shape.
+ * @see {@link UpdateDevicePoolCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateDevicePoolCommand extends $Command<UpdateDevicePoolCommandInput, UpdateDevicePoolCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateDevicePoolCommandInput;
+    constructor(input: UpdateDevicePoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDevicePoolCommandInput, UpdateDevicePoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateInstanceProfileCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateInstanceProfileRequest, UpdateInstanceProfileResult } from "../models/models_0";
+export interface UpdateInstanceProfileCommandInput extends UpdateInstanceProfileRequest {
+}
+export interface UpdateInstanceProfileCommandOutput extends UpdateInstanceProfileResult, __MetadataBearer {
+}
+/**
+ * <p>Updates information about an existing private device instance profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateInstanceProfileCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateInstanceProfileCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateInstanceProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateInstanceProfileCommandInput} for command's `input` shape.
+ * @see {@link UpdateInstanceProfileCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateInstanceProfileCommand extends $Command<UpdateInstanceProfileCommandInput, UpdateInstanceProfileCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateInstanceProfileCommandInput;
+    constructor(input: UpdateInstanceProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateInstanceProfileCommandInput, UpdateInstanceProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateNetworkProfileCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateNetworkProfileRequest, UpdateNetworkProfileResult } from "../models/models_0";
+export interface UpdateNetworkProfileCommandInput extends UpdateNetworkProfileRequest {
+}
+export interface UpdateNetworkProfileCommandOutput extends UpdateNetworkProfileResult, __MetadataBearer {
+}
+/**
+ * <p>Updates the network profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateNetworkProfileCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateNetworkProfileCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateNetworkProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateNetworkProfileCommandInput} for command's `input` shape.
+ * @see {@link UpdateNetworkProfileCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateNetworkProfileCommand extends $Command<UpdateNetworkProfileCommandInput, UpdateNetworkProfileCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateNetworkProfileCommandInput;
+    constructor(input: UpdateNetworkProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateNetworkProfileCommandInput, UpdateNetworkProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateProjectCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateProjectRequest, UpdateProjectResult } from "../models/models_0";
+export interface UpdateProjectCommandInput extends UpdateProjectRequest {
+}
+export interface UpdateProjectCommandOutput extends UpdateProjectResult, __MetadataBearer {
+}
+/**
+ * <p>Modifies the specified project name, given the project ARN and a new
+ *             name.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateProjectCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateProjectCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateProjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateProjectCommandInput} for command's `input` shape.
+ * @see {@link UpdateProjectCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateProjectCommand extends $Command<UpdateProjectCommandInput, UpdateProjectCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateProjectCommandInput;
+    constructor(input: UpdateProjectCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProjectCommandInput, UpdateProjectCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateTestGridProjectCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateTestGridProjectRequest, UpdateTestGridProjectResult } from "../models/models_0";
+export interface UpdateTestGridProjectCommandInput extends UpdateTestGridProjectRequest {
+}
+export interface UpdateTestGridProjectCommandOutput extends UpdateTestGridProjectResult, __MetadataBearer {
+}
+/**
+ * <p>Change details of a project.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateTestGridProjectCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateTestGridProjectCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateTestGridProjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateTestGridProjectCommandInput} for command's `input` shape.
+ * @see {@link UpdateTestGridProjectCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateTestGridProjectCommand extends $Command<UpdateTestGridProjectCommandInput, UpdateTestGridProjectCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateTestGridProjectCommandInput;
+    constructor(input: UpdateTestGridProjectCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTestGridProjectCommandInput, UpdateTestGridProjectCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateUploadCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateUploadRequest, UpdateUploadResult } from "../models/models_0";
+export interface UpdateUploadCommandInput extends UpdateUploadRequest {
+}
+export interface UpdateUploadCommandOutput extends UpdateUploadResult, __MetadataBearer {
+}
+/**
+ * <p>Updates an uploaded test spec.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateUploadCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateUploadCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateUploadCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUploadCommandInput} for command's `input` shape.
+ * @see {@link UpdateUploadCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUploadCommand extends $Command<UpdateUploadCommandInput, UpdateUploadCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateUploadCommandInput;
+    constructor(input: UpdateUploadCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUploadCommandInput, UpdateUploadCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateVPCEConfigurationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
+import { UpdateVPCEConfigurationRequest, UpdateVPCEConfigurationResult } from "../models/models_0";
+export interface UpdateVPCEConfigurationCommandInput extends UpdateVPCEConfigurationRequest {
+}
+export interface UpdateVPCEConfigurationCommandOutput extends UpdateVPCEConfigurationResult, __MetadataBearer {
+}
+/**
+ * <p>Updates information about an Amazon Virtual Private Cloud (VPC) endpoint configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, UpdateVPCEConfigurationCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, UpdateVPCEConfigurationCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new UpdateVPCEConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateVPCEConfigurationCommandInput} for command's `input` shape.
+ * @see {@link UpdateVPCEConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateVPCEConfigurationCommand extends $Command<UpdateVPCEConfigurationCommandInput, UpdateVPCEConfigurationCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: UpdateVPCEConfigurationCommandInput;
+    constructor(input: UpdateVPCEConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateVPCEConfigurationCommandInput, UpdateVPCEConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/pagination/GetOfferingStatusPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { GetOfferingStatusCommandInput, GetOfferingStatusCommandOutput } from "../commands/GetOfferingStatusCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateGetOfferingStatus(config: DeviceFarmPaginationConfiguration, input: GetOfferingStatusCommandInput, ...additionalArguments: any): Paginator<GetOfferingStatusCommandOutput>;

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { DeviceFarm } from "../DeviceFarm";
+import { DeviceFarmClient } from "../DeviceFarmClient";
+export interface DeviceFarmPaginationConfiguration extends PaginationConfiguration {
+    client: DeviceFarm | DeviceFarmClient;
+}

package/dist-types/ts3.4/pagination/ListArtifactsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListArtifactsCommandInput, ListArtifactsCommandOutput } from "../commands/ListArtifactsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListArtifacts(config: DeviceFarmPaginationConfiguration, input: ListArtifactsCommandInput, ...additionalArguments: any): Paginator<ListArtifactsCommandOutput>;

package/dist-types/ts3.4/pagination/ListDevicePoolsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListDevicePoolsCommandInput, ListDevicePoolsCommandOutput } from "../commands/ListDevicePoolsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListDevicePools(config: DeviceFarmPaginationConfiguration, input: ListDevicePoolsCommandInput, ...additionalArguments: any): Paginator<ListDevicePoolsCommandOutput>;

package/dist-types/ts3.4/pagination/ListDevicesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListDevicesCommandInput, ListDevicesCommandOutput } from "../commands/ListDevicesCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListDevices(config: DeviceFarmPaginationConfiguration, input: ListDevicesCommandInput, ...additionalArguments: any): Paginator<ListDevicesCommandOutput>;

package/dist-types/ts3.4/pagination/ListJobsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListJobsCommandInput, ListJobsCommandOutput } from "../commands/ListJobsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListJobs(config: DeviceFarmPaginationConfiguration, input: ListJobsCommandInput, ...additionalArguments: any): Paginator<ListJobsCommandOutput>;

package/dist-types/ts3.4/pagination/ListOfferingTransactionsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListOfferingTransactionsCommandInput, ListOfferingTransactionsCommandOutput } from "../commands/ListOfferingTransactionsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListOfferingTransactions(config: DeviceFarmPaginationConfiguration, input: ListOfferingTransactionsCommandInput, ...additionalArguments: any): Paginator<ListOfferingTransactionsCommandOutput>;

package/dist-types/ts3.4/pagination/ListOfferingsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListOfferingsCommandInput, ListOfferingsCommandOutput } from "../commands/ListOfferingsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListOfferings(config: DeviceFarmPaginationConfiguration, input: ListOfferingsCommandInput, ...additionalArguments: any): Paginator<ListOfferingsCommandOutput>;

package/dist-types/ts3.4/pagination/ListProjectsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListProjectsCommandInput, ListProjectsCommandOutput } from "../commands/ListProjectsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListProjects(config: DeviceFarmPaginationConfiguration, input: ListProjectsCommandInput, ...additionalArguments: any): Paginator<ListProjectsCommandOutput>;

package/dist-types/ts3.4/pagination/ListRunsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListRunsCommandInput, ListRunsCommandOutput } from "../commands/ListRunsCommand";
+import { DeviceFarmPaginationConfiguration } from "./Interfaces";
+export declare function paginateListRuns(config: DeviceFarmPaginationConfiguration, input: ListRunsCommandInput, ...additionalArguments: any): Paginator<ListRunsCommandOutput>;