Module aws_sdk_outposts::model

source ·
Expand description

Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

Modules

address
See Address.
asset_info
See AssetInfo.
asset_location
See AssetLocation.
catalog_item
See CatalogItem.
compute_attributes
See ComputeAttributes.
connection_details
See ConnectionDetails.
ec2_capacity
See Ec2Capacity.
instance_type_item
See InstanceTypeItem.
line_item
See LineItem.
line_item_asset_information
See LineItemAssetInformation.
line_item_request
See LineItemRequest.
order
See Order.
order_summary
See OrderSummary.
outpost
See Outpost.
rack_physical_properties
See RackPhysicalProperties.
shipment_information
See ShipmentInformation.
site
See Site.

Structs

Address

Information about an address.

AssetInfo

Information about hardware assets.

AssetLocation

Information about the position of the asset in a rack.

CatalogItem

Information about a catalog item.

ComputeAttributes

Information about compute hardware assets.

ConnectionDetails

Information about a connection.

Ec2Capacity

Information about EC2 capacity.

InstanceTypeItem

Information about an instance type.

LineItem

Information about a line item.

LineItemAssetInformation

Information about a line item asset.

LineItemRequest

Information about a line item request.

Order

Information about an order.

OrderSummary

A summary of line items in your order.

Outpost

Information about an Outpost.

RackPhysicalProperties

Information about the physical and logistical details for racks at sites. For more information about hardware requirements for racks, see Network readiness checklist in the Amazon Web Services Outposts User Guide.

ShipmentInformation

Information about a line item shipment.

Site

Information about a site.

Enums

AddressType
When writing a match expression against AddressType, 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.
AssetType
When writing a match expression against AssetType, 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.
CatalogItemClass
When writing a match expression against CatalogItemClass, 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.
CatalogItemStatus
When writing a match expression against CatalogItemStatus, 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.
FiberOpticCableType
When writing a match expression against FiberOpticCableType, 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.
LineItemStatus
When writing a match expression against LineItemStatus, 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.
MaximumSupportedWeightLbs
When writing a match expression against MaximumSupportedWeightLbs, 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.
OpticalStandard
When writing a match expression against OpticalStandard, 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.
OrderStatus
When writing a match expression against OrderStatus, 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.
OrderType
When writing a match expression against OrderType, 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.
PaymentOption
When writing a match expression against PaymentOption, 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.
PaymentTerm
When writing a match expression against PaymentTerm, 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.
PowerConnector
When writing a match expression against PowerConnector, 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.
PowerDrawKva
When writing a match expression against PowerDrawKva, 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.
PowerFeedDrop
When writing a match expression against PowerFeedDrop, 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.
PowerPhase
When writing a match expression against PowerPhase, 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.
ResourceType
When writing a match expression against ResourceType, 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.
ShipmentCarrier
When writing a match expression against ShipmentCarrier, 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.
SupportedHardwareType
When writing a match expression against SupportedHardwareType, 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.
SupportedStorageEnum
When writing a match expression against SupportedStorageEnum, 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.
UplinkCount
When writing a match expression against UplinkCount, 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.
UplinkGbps
When writing a match expression against UplinkGbps, 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.