Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS Device Farm can respond with.

Structs

AccountSettings

A container for account-level settings in AWS Device Farm.

Artifact

Represents the output of a test. Examples of artifacts include logs and screenshots.

Counters

Represents entity counters.

Cpu

Represents the amount of CPU that an app is using on a physical device. Does not represent system-wide CPU usage.

CreateRemoteAccessSessionConfiguration

Configuration settings for a remote access session, including billing method.

CustomerArtifactPaths

A JSON object that specifies the paths where the artifacts generated by the customer's tests, on the device or in the test environment, are pulled from.

Specify deviceHostPaths and optionally specify either iosPaths or androidPaths.

For web app tests, you can specify both iosPaths and androidPaths.

Device

Represents a device type that an app is tested against.

DeviceFilter

Represents a device filter used to select a set of devices to be included in a test run. This data structure is passed in as the deviceSelectionConfiguration parameter to ScheduleRun. For an example of the JSON request syntax, see ScheduleRun.

It is also passed in as the filters parameter to ListDevices. For an example of the JSON request syntax, see ListDevices.

DeviceInstance

Represents the device instance.

DeviceMinutes

Represents the total (metered or unmetered) minutes used by the resource to run tests. Contains the sum of minutes consumed by all children.

DevicePool

Represents a collection of device types.

DevicePoolCompatibilityResult

Represents a device pool compatibility result.

DeviceProxy

Represents the http/s proxy configuration that will be applied to a device during a run.

DeviceSelectionConfiguration

Represents the device filters used in a test run and the maximum number of devices to be included in the run. It is passed in as the deviceSelectionConfiguration request parameter in ScheduleRun.

DeviceSelectionResult

Contains the run results requested by the device selection configuration and how many devices were returned. For an example of the JSON response syntax, see ScheduleRun.

ExecutionConfiguration

Represents configuration information about a test run, such as the execution timeout (in minutes).

IncompatibilityMessage

Represents information about incompatibility.

InstanceProfile

Represents the instance profile.

Job

Represents a device.

Location

Represents a latitude and longitude pair, expressed in geographic coordinate system degrees (for example, 47.6204, -122.3491).

Elevation is currently not supported.

MonetaryAmount

A number that represents the monetary amount for an offering or transaction.

NetworkProfile

An array of settings that describes characteristics of a network profile.

Offering

Represents the metadata of a device offering.

OfferingPromotion

Represents information about an offering promotion.

OfferingStatus

The status of the offering.

OfferingTransaction

Represents the metadata of an offering transaction.

Problem

Represents a specific warning or failure.

ProblemDetail

Information about a problem detail.

Project

Represents an operating-system neutral workspace for running and managing tests.

Radios

Represents the set of radios and their states on a device. Examples of radios include Wi-Fi, GPS, Bluetooth, and NFC.

RecurringCharge

Specifies whether charges for devices are recurring.

RemoteAccessSession

Represents information about the remote access session.

Resolution

Represents the screen resolution of a device in height and width, expressed in pixels.

Rule

Represents a condition for a device pool.

Run

Represents a test run on a set of devices with a given app package, test parameters, and so on.

Sample

Represents a sample of performance data.

ScheduleRunConfiguration

Represents the settings for a run. Includes things like location, radio states, auxiliary apps, and network profiles.

ScheduleRunTest

Represents test settings. This data structure is passed in as the test parameter to ScheduleRun. For an example of the JSON request syntax, see ScheduleRun.

Suite

Represents a collection of one or more tests.

Tag

The metadata that you apply to a resource to help you categorize and organize it. Each tag consists of a key and an optional value, both of which you define. Tag keys can have a maximum character length of 128 characters. Tag values can have a maximum length of 256 characters.

Test

Represents a condition that is evaluated.

TestGridProject

A Selenium testing project. Projects are used to collect and collate sessions.

TestGridSession

A TestGridSession is a single instance of a browser launched from the URL provided by a call to CreateTestGridUrl.

TestGridSessionAction

An action taken by a TestGridSession browser instance.

TestGridSessionArtifact

Artifacts are video and other files that are produced in the process of running a browser in an automated context.

Video elements might be broken up into multiple artifacts as they grow in size during creation.

TestGridVpcConfig

The VPC security groups and subnets that are attached to a project.

TrialMinutes

Represents information about free trial device minutes for an AWS account.

UniqueProblem

A collection of one or more problems, grouped by their result.

Upload

An app or a set of one or more tests to upload or that have been uploaded.

VpcConfig

Contains the VPC configuration data necessary to interface with AWS Device Farm's services.

VpceConfiguration

Represents an Amazon Virtual Private Cloud (VPC) endpoint configuration.

Enums

ArtifactCategory

When writing a match expression against ArtifactCategory, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ArtifactType

When writing a match expression against ArtifactType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

BillingMethod

When writing a match expression against BillingMethod, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CurrencyCode

When writing a match expression against CurrencyCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeviceAttribute

When writing a match expression against DeviceAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeviceAvailability

When writing a match expression against DeviceAvailability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeviceFilterAttribute

When writing a match expression against DeviceFilterAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeviceFormFactor

When writing a match expression against DeviceFormFactor, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DevicePlatform

When writing a match expression against DevicePlatform, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DevicePoolType

When writing a match expression against DevicePoolType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionResult

When writing a match expression against ExecutionResult, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionResultCode

When writing a match expression against ExecutionResultCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionStatus

When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InstanceStatus

When writing a match expression against InstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InteractionMode

When writing a match expression against InteractionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NetworkProfileType

When writing a match expression against NetworkProfileType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OfferingTransactionType

When writing a match expression against OfferingTransactionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OfferingType

When writing a match expression against OfferingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecurringChargeFrequency

When writing a match expression against RecurringChargeFrequency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RuleOperator

When writing a match expression against RuleOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SampleType

When writing a match expression against SampleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TestGridSessionArtifactCategory

When writing a match expression against TestGridSessionArtifactCategory, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TestGridSessionArtifactType

When writing a match expression against TestGridSessionArtifactType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TestGridSessionStatus

When writing a match expression against TestGridSessionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TestType

When writing a match expression against TestType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UploadCategory

When writing a match expression against UploadCategory, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UploadStatus

When writing a match expression against UploadStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UploadType

When writing a match expression against UploadType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.