Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS RoboMaker can respond with.

Structs

BatchPolicy

Information about the batch policy.

Compute

Compute information for the simulation job.

ComputeResponse

Compute information for the simulation job

DataSource

Information about a data source.

DataSourceConfig

Information about a data source.

DeploymentApplicationConfig

Information about a deployment application configuration.

DeploymentConfig

Information about a deployment configuration.

DeploymentJob

Information about a deployment job.

DeploymentLaunchConfig

Configuration information for a deployment launch.

Environment

The object that contains the Docker image URI for either your robot or simulation applications.

FailedCreateSimulationJobRequest

Information about a failed create simulation job request.

FailureSummary

Information about worlds that failed.

Filter

Information about a filter.

FinishedWorldsSummary

Information about worlds that finished.

Fleet

Information about a fleet.

LaunchConfig

Information about a launch configuration.

LoggingConfig

The logging configuration.

NetworkInterface

Describes a network interface.

OutputLocation

The output location.

PortForwardingConfig

Configuration information for port forwarding.

PortMapping

An object representing a port mapping.

ProgressDetail

Information about the progress of a deployment job.

RenderingEngine

Information about a rendering engine.

Robot

Information about a robot.

RobotApplicationConfig

Application configuration information for a robot.

RobotApplicationSummary

Summary information for a robot application.

RobotDeployment

Information about a robot deployment.

RobotSoftwareSuite

Information about a robot software suite.

S3KeyOutput

Information about S3 keys.

S3Object

Information about an S3 object.

SimulationApplicationConfig

Information about a simulation application configuration.

SimulationApplicationSummary

Summary information for a simulation application.

SimulationJob

Information about a simulation job.

SimulationJobBatchSummary

Information about a simulation job batch.

SimulationJobRequest

Information about a simulation job request.

SimulationJobSummary

Summary information for a simulation job.

SimulationSoftwareSuite

Information about a simulation software suite.

Source

Information about a source.

SourceConfig

Information about a source configuration.

TemplateLocation

Information about a template location.

TemplateSummary

Summary information for a template.

Tool

Information about a tool. Tools are used in a simulation job.

UploadConfiguration

Provides upload configuration information. Files are uploaded from the simulation job to a location you specify.

VpcConfig

If your simulation job accesses resources in a VPC, you provide this parameter identifying the list of security group IDs and subnet IDs. These must belong to the same VPC. You must provide at least one security group and two subnet IDs.

VpcConfigResponse

VPC configuration associated with your simulation job.

WorldConfig

Configuration information for a world.

WorldCount

The number of worlds that will be created. You can configure the number of unique floorplans and the number of unique interiors for each floor plan. For example, if you want 1 world with 20 unique interiors, you set floorplanCount = 1 and interiorCountPerFloorplan = 20. This will result in 20 worlds (floorplanCount * interiorCountPerFloorplan).

If you set floorplanCount = 4 and interiorCountPerFloorplan = 5, there will be 20 worlds with 5 unique floor plans.

WorldExportJobSummary

Information about a world export job.

WorldFailure

Information about a failed world.

WorldGenerationJobSummary

Information about a world generator job.

WorldSummary

Information about a world.

Enums

Architecture

When writing a match expression against Architecture, 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.

ComputeType

When writing a match expression against ComputeType, 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.

DataSourceType

When writing a match expression against DataSourceType, 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.

DeploymentJobErrorCode

When writing a match expression against DeploymentJobErrorCode, 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.

DeploymentStatus

When writing a match expression against DeploymentStatus, 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.

ExitBehavior

When writing a match expression against ExitBehavior, 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.

FailureBehavior

When writing a match expression against FailureBehavior, 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.

RenderingEngineType

When writing a match expression against RenderingEngineType, 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.

RobotDeploymentStep

When writing a match expression against RobotDeploymentStep, 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.

RobotSoftwareSuiteType

When writing a match expression against RobotSoftwareSuiteType, 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.

RobotSoftwareSuiteVersionType

When writing a match expression against RobotSoftwareSuiteVersionType, 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.

RobotStatus

When writing a match expression against RobotStatus, 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.

SimulationJobBatchErrorCode

When writing a match expression against SimulationJobBatchErrorCode, 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.

SimulationJobBatchStatus

When writing a match expression against SimulationJobBatchStatus, 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.

SimulationJobErrorCode

When writing a match expression against SimulationJobErrorCode, 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.

SimulationJobStatus

When writing a match expression against SimulationJobStatus, 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.

SimulationSoftwareSuiteType

When writing a match expression against SimulationSoftwareSuiteType, 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.

UploadBehavior

When writing a match expression against UploadBehavior, 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.

WorldExportJobErrorCode

When writing a match expression against WorldExportJobErrorCode, 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.

WorldExportJobStatus

When writing a match expression against WorldExportJobStatus, 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.

WorldGenerationJobErrorCode

When writing a match expression against WorldGenerationJobErrorCode, 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.

WorldGenerationJobStatus

When writing a match expression against WorldGenerationJobStatus, 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.