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

package/dist-types/commands/GetRemoteAccessSessionCommand.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 { GetRemoteAccessSessionRequest, GetRemoteAccessSessionResult } from "../models/models_0";
+export interface GetRemoteAccessSessionCommandInput extends GetRemoteAccessSessionRequest {
+}
+export interface GetRemoteAccessSessionCommandOutput extends GetRemoteAccessSessionResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a link to a currently running remote access session.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetRemoteAccessSessionCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetRemoteAccessSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRemoteAccessSessionCommandInput} for command's `input` shape.
+ * @see {@link GetRemoteAccessSessionCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRemoteAccessSessionCommand extends $Command<GetRemoteAccessSessionCommandInput, GetRemoteAccessSessionCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetRemoteAccessSessionCommandInput;
+    constructor(input: GetRemoteAccessSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRemoteAccessSessionCommandInput, GetRemoteAccessSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetRunCommand.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 { GetRunRequest, GetRunResult } from "../models/models_0";
+export interface GetRunCommandInput extends GetRunRequest {
+}
+export interface GetRunCommandOutput extends GetRunResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about a run.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetRunCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetRunCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetRunCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRunCommandInput} for command's `input` shape.
+ * @see {@link GetRunCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRunCommand extends $Command<GetRunCommandInput, GetRunCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetRunCommandInput;
+    constructor(input: GetRunCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRunCommandInput, GetRunCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSuiteCommand.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 { GetSuiteRequest, GetSuiteResult } from "../models/models_0";
+export interface GetSuiteCommandInput extends GetSuiteRequest {
+}
+export interface GetSuiteCommandOutput extends GetSuiteResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about a suite.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetSuiteCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetSuiteCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetSuiteCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSuiteCommandInput} for command's `input` shape.
+ * @see {@link GetSuiteCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSuiteCommand extends $Command<GetSuiteCommandInput, GetSuiteCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetSuiteCommandInput;
+    constructor(input: GetSuiteCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSuiteCommandInput, GetSuiteCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTestCommand.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 { GetTestRequest, GetTestResult } from "../models/models_0";
+export interface GetTestCommandInput extends GetTestRequest {
+}
+export interface GetTestCommandOutput extends GetTestResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about a test.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetTestCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetTestCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetTestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTestCommandInput} for command's `input` shape.
+ * @see {@link GetTestCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTestCommand extends $Command<GetTestCommandInput, GetTestCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetTestCommandInput;
+    constructor(input: GetTestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTestCommandInput, GetTestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTestGridProjectCommand.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 { GetTestGridProjectRequest, GetTestGridProjectResult } from "../models/models_0";
+export interface GetTestGridProjectCommandInput extends GetTestGridProjectRequest {
+}
+export interface GetTestGridProjectCommandOutput extends GetTestGridProjectResult, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about a Selenium testing project.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetTestGridProjectCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetTestGridProjectCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetTestGridProjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTestGridProjectCommandInput} for command's `input` shape.
+ * @see {@link GetTestGridProjectCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTestGridProjectCommand extends $Command<GetTestGridProjectCommandInput, GetTestGridProjectCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetTestGridProjectCommandInput;
+    constructor(input: GetTestGridProjectCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTestGridProjectCommandInput, GetTestGridProjectCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTestGridSessionCommand.d.ts

@@ -0,0 +1,44 @@
+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 { GetTestGridSessionRequest, GetTestGridSessionResult } from "../models/models_0";
+export interface GetTestGridSessionCommandInput extends GetTestGridSessionRequest {
+}
+export interface GetTestGridSessionCommandOutput extends GetTestGridSessionResult, __MetadataBearer {
+}
+/**
+ * <p>A session is an instance of a browser created through a <code>RemoteWebDriver</code> with the URL from <a>CreateTestGridUrlResult$url</a>. You can use the following to look up sessions:</p>
+ *          <ul>
+ *             <li>
+ *                <p>The session ARN (<a>GetTestGridSessionRequest$sessionArn</a>).</p>
+ *             </li>
+ *             <li>
+ *                <p>The project ARN and a session ID (<a>GetTestGridSessionRequest$projectArn</a> and <a>GetTestGridSessionRequest$sessionId</a>).</p>
+ *             </li>
+ *          </ul>
+ *          <p></p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetTestGridSessionCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetTestGridSessionCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetTestGridSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTestGridSessionCommandInput} for command's `input` shape.
+ * @see {@link GetTestGridSessionCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTestGridSessionCommand extends $Command<GetTestGridSessionCommandInput, GetTestGridSessionCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetTestGridSessionCommandInput;
+    constructor(input: GetTestGridSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTestGridSessionCommandInput, GetTestGridSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetUploadCommand.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 { GetUploadRequest, GetUploadResult } from "../models/models_0";
+export interface GetUploadCommandInput extends GetUploadRequest {
+}
+export interface GetUploadCommandOutput extends GetUploadResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about an upload.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, GetUploadCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetUploadCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetUploadCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUploadCommandInput} for command's `input` shape.
+ * @see {@link GetUploadCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUploadCommand extends $Command<GetUploadCommandInput, GetUploadCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetUploadCommandInput;
+    constructor(input: GetUploadCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUploadCommandInput, GetUploadCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVPCEConfigurationCommand.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 { GetVPCEConfigurationRequest, GetVPCEConfigurationResult } from "../models/models_0";
+export interface GetVPCEConfigurationCommandInput extends GetVPCEConfigurationRequest {
+}
+export interface GetVPCEConfigurationCommandOutput extends GetVPCEConfigurationResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about the configuration settings 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, GetVPCEConfigurationCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, GetVPCEConfigurationCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new GetVPCEConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVPCEConfigurationCommandInput} for command's `input` shape.
+ * @see {@link GetVPCEConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetVPCEConfigurationCommand extends $Command<GetVPCEConfigurationCommandInput, GetVPCEConfigurationCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: GetVPCEConfigurationCommandInput;
+    constructor(input: GetVPCEConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVPCEConfigurationCommandInput, GetVPCEConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/InstallToRemoteAccessSessionCommand.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 { InstallToRemoteAccessSessionRequest, InstallToRemoteAccessSessionResult } from "../models/models_0";
+export interface InstallToRemoteAccessSessionCommandInput extends InstallToRemoteAccessSessionRequest {
+}
+export interface InstallToRemoteAccessSessionCommandOutput extends InstallToRemoteAccessSessionResult, __MetadataBearer {
+}
+/**
+ * <p>Installs an application to the device in a remote access session. For Android
+ *             applications, the file must be in .apk format. For iOS applications, the file must be in
+ *             .ipa format.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, InstallToRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, InstallToRemoteAccessSessionCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new InstallToRemoteAccessSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link InstallToRemoteAccessSessionCommandInput} for command's `input` shape.
+ * @see {@link InstallToRemoteAccessSessionCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class InstallToRemoteAccessSessionCommand extends $Command<InstallToRemoteAccessSessionCommandInput, InstallToRemoteAccessSessionCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: InstallToRemoteAccessSessionCommandInput;
+    constructor(input: InstallToRemoteAccessSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InstallToRemoteAccessSessionCommandInput, InstallToRemoteAccessSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListArtifactsCommand.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 { ListArtifactsRequest, ListArtifactsResult } from "../models/models_0";
+export interface ListArtifactsCommandInput extends ListArtifactsRequest {
+}
+export interface ListArtifactsCommandOutput extends ListArtifactsResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about artifacts.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListArtifactsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListArtifactsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListArtifactsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListArtifactsCommandInput} for command's `input` shape.
+ * @see {@link ListArtifactsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListArtifactsCommand extends $Command<ListArtifactsCommandInput, ListArtifactsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListArtifactsCommandInput;
+    constructor(input: ListArtifactsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListArtifactsCommandInput, ListArtifactsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDeviceInstancesCommand.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 { ListDeviceInstancesRequest, ListDeviceInstancesResult } from "../models/models_0";
+export interface ListDeviceInstancesCommandInput extends ListDeviceInstancesRequest {
+}
+export interface ListDeviceInstancesCommandOutput extends ListDeviceInstancesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about the private device instances associated with one or more AWS
+ *             accounts.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListDeviceInstancesCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListDeviceInstancesCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListDeviceInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDeviceInstancesCommandInput} for command's `input` shape.
+ * @see {@link ListDeviceInstancesCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDeviceInstancesCommand extends $Command<ListDeviceInstancesCommandInput, ListDeviceInstancesCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListDeviceInstancesCommandInput;
+    constructor(input: ListDeviceInstancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDeviceInstancesCommandInput, ListDeviceInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDevicePoolsCommand.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 { ListDevicePoolsRequest, ListDevicePoolsResult } from "../models/models_0";
+export interface ListDevicePoolsCommandInput extends ListDevicePoolsRequest {
+}
+export interface ListDevicePoolsCommandOutput extends ListDevicePoolsResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about device pools.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListDevicePoolsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListDevicePoolsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListDevicePoolsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDevicePoolsCommandInput} for command's `input` shape.
+ * @see {@link ListDevicePoolsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDevicePoolsCommand extends $Command<ListDevicePoolsCommandInput, ListDevicePoolsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListDevicePoolsCommandInput;
+    constructor(input: ListDevicePoolsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDevicePoolsCommandInput, ListDevicePoolsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDevicesCommand.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 { ListDevicesRequest, ListDevicesResult } from "../models/models_0";
+export interface ListDevicesCommandInput extends ListDevicesRequest {
+}
+export interface ListDevicesCommandOutput extends ListDevicesResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about unique device types.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListDevicesCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListDevicesCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListDevicesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDevicesCommandInput} for command's `input` shape.
+ * @see {@link ListDevicesCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDevicesCommand extends $Command<ListDevicesCommandInput, ListDevicesCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListDevicesCommandInput;
+    constructor(input: ListDevicesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDevicesCommandInput, ListDevicesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListInstanceProfilesCommand.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 { ListInstanceProfilesRequest, ListInstanceProfilesResult } from "../models/models_0";
+export interface ListInstanceProfilesCommandInput extends ListInstanceProfilesRequest {
+}
+export interface ListInstanceProfilesCommandOutput extends ListInstanceProfilesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about all the instance profiles in an AWS account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListInstanceProfilesCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListInstanceProfilesCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListInstanceProfilesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListInstanceProfilesCommandInput} for command's `input` shape.
+ * @see {@link ListInstanceProfilesCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListInstanceProfilesCommand extends $Command<ListInstanceProfilesCommandInput, ListInstanceProfilesCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListInstanceProfilesCommandInput;
+    constructor(input: ListInstanceProfilesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInstanceProfilesCommandInput, ListInstanceProfilesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListJobsCommand.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 { ListJobsRequest, ListJobsResult } from "../models/models_0";
+export interface ListJobsCommandInput extends ListJobsRequest {
+}
+export interface ListJobsCommandOutput extends ListJobsResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about jobs for a given test run.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListJobsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListJobsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListJobsCommandInput} for command's `input` shape.
+ * @see {@link ListJobsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListJobsCommand extends $Command<ListJobsCommandInput, ListJobsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListJobsCommandInput;
+    constructor(input: ListJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListJobsCommandInput, ListJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListNetworkProfilesCommand.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 { ListNetworkProfilesRequest, ListNetworkProfilesResult } from "../models/models_0";
+export interface ListNetworkProfilesCommandInput extends ListNetworkProfilesRequest {
+}
+export interface ListNetworkProfilesCommandOutput extends ListNetworkProfilesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the list of available network profiles.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListNetworkProfilesCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListNetworkProfilesCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListNetworkProfilesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListNetworkProfilesCommandInput} for command's `input` shape.
+ * @see {@link ListNetworkProfilesCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListNetworkProfilesCommand extends $Command<ListNetworkProfilesCommandInput, ListNetworkProfilesCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListNetworkProfilesCommandInput;
+    constructor(input: ListNetworkProfilesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNetworkProfilesCommandInput, ListNetworkProfilesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListOfferingPromotionsCommand.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 { ListOfferingPromotionsRequest, ListOfferingPromotionsResult } from "../models/models_0";
+export interface ListOfferingPromotionsCommandInput extends ListOfferingPromotionsRequest {
+}
+export interface ListOfferingPromotionsCommandOutput extends ListOfferingPromotionsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of offering promotions. Each offering promotion record contains the ID and description
+ *             of the promotion. The API returns a <code>NotEligible</code> error if the caller is not permitted to invoke
+ *             the operation. Contact <a href="mailto:aws-devicefarm-support@amazon.com">aws-devicefarm-support@amazon.com</a> if you must be able to invoke this operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListOfferingPromotionsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListOfferingPromotionsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListOfferingPromotionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListOfferingPromotionsCommandInput} for command's `input` shape.
+ * @see {@link ListOfferingPromotionsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListOfferingPromotionsCommand extends $Command<ListOfferingPromotionsCommandInput, ListOfferingPromotionsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListOfferingPromotionsCommandInput;
+    constructor(input: ListOfferingPromotionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOfferingPromotionsCommandInput, ListOfferingPromotionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}