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.

• 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.