Module aws_sdk_devicefarm::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.

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

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

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

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