Module aws_sdk_robomaker::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 (ROS distribution).

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

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