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

package/dist-types/ts3.4/commands/ListOfferingTransactionsCommand.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 { ListOfferingTransactionsRequest, ListOfferingTransactionsResult } from "../models/models_0";
+export interface ListOfferingTransactionsCommandInput extends ListOfferingTransactionsRequest {
+}
+export interface ListOfferingTransactionsCommandOutput extends ListOfferingTransactionsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of all historical purchases, renewals, and system renewal transactions for an AWS
+ *             account. The list is paginated and ordered by a descending timestamp (most recent transactions are first).
+ *             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, ListOfferingTransactionsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListOfferingTransactionsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListOfferingTransactionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListOfferingTransactionsCommandInput} for command's `input` shape.
+ * @see {@link ListOfferingTransactionsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListOfferingTransactionsCommand extends $Command<ListOfferingTransactionsCommandInput, ListOfferingTransactionsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListOfferingTransactionsCommandInput;
+    constructor(input: ListOfferingTransactionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOfferingTransactionsCommandInput, ListOfferingTransactionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListOfferingsCommand.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 { ListOfferingsRequest, ListOfferingsResult } from "../models/models_0";
+export interface ListOfferingsCommandInput extends ListOfferingsRequest {
+}
+export interface ListOfferingsCommandOutput extends ListOfferingsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of products or offerings that the user can manage through the API. Each offering record
+ *             indicates the recurring price per unit and the frequency for that offering. 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, ListOfferingsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListOfferingsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListOfferingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListOfferingsCommandInput} for command's `input` shape.
+ * @see {@link ListOfferingsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListOfferingsCommand extends $Command<ListOfferingsCommandInput, ListOfferingsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListOfferingsCommandInput;
+    constructor(input: ListOfferingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOfferingsCommandInput, ListOfferingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+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 { ListUniqueProblemsRequest, ListUniqueProblemsResult } from "../models/models_0";
+export interface ListUniqueProblemsCommandInput extends ListUniqueProblemsRequest {
+}
+export interface ListUniqueProblemsCommandOutput extends ListUniqueProblemsResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about unique problems, such as exceptions or crashes.</p>
+ *         <p>Unique problems are defined as a single instance of an error across a run, job, or suite. For example,
+ *             if a call in your application consistently raises an exception (<code>OutOfBoundsException in
+ *                 MyActivity.java:386</code>), <code>ListUniqueProblems</code> returns a single entry instead of many
+ *             individual entries for that exception.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, ListUniqueProblemsCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, ListUniqueProblemsCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new ListUniqueProblemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUniqueProblemsCommandInput} for command's `input` shape.
+ * @see {@link ListUniqueProblemsCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUniqueProblemsCommand extends $Command<ListUniqueProblemsCommandInput, ListUniqueProblemsCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: ListUniqueProblemsCommandInput;
+    constructor(input: ListUniqueProblemsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUniqueProblemsCommandInput, ListUniqueProblemsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/PurchaseOfferingCommand.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 { PurchaseOfferingRequest, PurchaseOfferingResult } from "../models/models_0";
+export interface PurchaseOfferingCommandInput extends PurchaseOfferingRequest {
+}
+export interface PurchaseOfferingCommandOutput extends PurchaseOfferingResult, __MetadataBearer {
+}
+/**
+ * <p>Immediately purchases offerings for an AWS account. Offerings renew with the latest total purchased
+ *             quantity for an offering, unless the renewal was overridden. The API returns a <code>NotEligible</code>
+ *             error if the user is not permitted to invoke the operation. If you must be able to invoke this operation,
+ *             contact <a href="mailto:aws-devicefarm-support@amazon.com">aws-devicefarm-support@amazon.com</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DeviceFarmClient, PurchaseOfferingCommand } from "@aws-sdk/client-device-farm"; // ES Modules import
+ * // const { DeviceFarmClient, PurchaseOfferingCommand } = require("@aws-sdk/client-device-farm"); // CommonJS import
+ * const client = new DeviceFarmClient(config);
+ * const command = new PurchaseOfferingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PurchaseOfferingCommandInput} for command's `input` shape.
+ * @see {@link PurchaseOfferingCommandOutput} for command's `response` shape.
+ * @see {@link DeviceFarmClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PurchaseOfferingCommand extends $Command<PurchaseOfferingCommandInput, PurchaseOfferingCommandOutput, DeviceFarmClientResolvedConfig> {
+    readonly input: PurchaseOfferingCommandInput;
+    constructor(input: PurchaseOfferingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DeviceFarmClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PurchaseOfferingCommandInput, PurchaseOfferingCommandOutput>;
+    private serialize;
+    private deserialize;
+}