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

package/dist/types/commands/GetRemoteAccessSessionCommand.d.ts

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetRemoteAccessSessionRequest, GetRemoteAccessSessionResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetRunRequest, GetRunResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetSuiteRequest, GetSuiteResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetTestRequest, GetTestResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetTestGridProjectRequest, GetTestGridProjectResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,44 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetTestGridSessionRequest, GetTestGridSessionResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetUploadRequest, GetUploadResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { GetVPCEConfigurationRequest, GetVPCEConfigurationResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,37 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { InstallToRemoteAccessSessionRequest, InstallToRemoteAccessSessionResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListArtifactsRequest, ListArtifactsResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListDeviceInstancesRequest, ListDeviceInstancesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListDevicePoolsRequest, ListDevicePoolsResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListDevicesRequest, ListDevicesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListInstanceProfilesRequest, ListInstanceProfilesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListJobsRequest, ListJobsResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListNetworkProfilesRequest, ListNetworkProfilesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,37 +0,0 @@
-import { DeviceFarmClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DeviceFarmClient";
-import { ListOfferingPromotionsRequest, ListOfferingPromotionsResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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;
-}