Module aws_sdk_dynamodb::types

source ·
Expand description

Data structures used by operation inputs/outputs.

Modules§

  • builders
    Builders
  • error
    Error types that Amazon DynamoDB can respond with.

Structs§

  • ArchivalSummary

    Contains details of a table archival operation.

  • AttributeDefinition

    Represents an attribute for describing the schema for the table and indexes.

  • AttributeValueUpdate

    For the UpdateItem operation, represents the attributes to be modified, the action to perform on each, and the new value for each.

    You cannot use UpdateItem to update any primary key attributes. Instead, you will need to delete the item, and then use PutItem to create a new item with new attributes.

    Attribute values cannot be null; string and binary type attributes must have lengths greater than zero; and set type attributes must not be empty. Requests with empty values will be rejected with a ValidationException exception.

  • AutoScalingPolicyDescription

    Represents the properties of the scaling policy.

  • AutoScalingPolicyUpdate

    Represents the auto scaling policy to be modified.

  • AutoScalingSettingsDescription

    Represents the auto scaling settings for a global table or global secondary index.

  • AutoScalingSettingsUpdate

    Represents the auto scaling settings to be modified for a global table or global secondary index.

  • AutoScalingTargetTrackingScalingPolicyConfigurationDescription

    Represents the properties of a target tracking scaling policy.

  • AutoScalingTargetTrackingScalingPolicyConfigurationUpdate

    Represents the settings of a target tracking scaling policy that will be modified.

  • BackupDescription

    Contains the description of the backup created for the table.

  • BackupDetails

    Contains the details of the backup created for the table.

  • BackupSummary

    Contains details for the backup.

  • BatchStatementError

    An error associated with a statement in a PartiQL batch that was run.

  • BatchStatementRequest

    A PartiQL batch statement request.

  • BatchStatementResponse

    A PartiQL batch statement response..

  • BillingModeSummary

    Contains the details for the read/write capacity mode. This page talks about PROVISIONED and PAY_PER_REQUEST billing modes. For more information about these modes, see Read/write capacity mode.

    You may need to switch to on-demand mode at least once in order to return a BillingModeSummary response.

  • CancellationReason

    An ordered list of errors for each item in the request which caused the transaction to get cancelled. The values of the list are ordered according to the ordering of the TransactWriteItems request parameter. If no error occurred for the associated item an error with a Null code and Null message will be present.

  • Capacity

    Represents the amount of provisioned throughput capacity consumed on a table or an index.

  • Condition

    Represents the selection criteria for a Query or Scan operation:

    • For a Query operation, Condition is used for specifying the KeyConditions to use when querying a table or an index. For KeyConditions, only the following comparison operators are supported:

      EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN

      Condition is also used in a QueryFilter, which evaluates the query results and returns only the desired values.

    • For a Scan operation, Condition is used in a ScanFilter, which evaluates the scan results and returns only the desired values.

  • ConditionCheck

    Represents a request to perform a check that an item exists or to check the condition of specific attributes of the item.

  • ConsumedCapacity

    The capacity units consumed by an operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. ConsumedCapacity is only returned if the request asked for it. For more information, see Provisioned capacity mode in the Amazon DynamoDB Developer Guide.

  • ContinuousBackupsDescription

    Represents the continuous backups and point in time recovery settings on the table.

  • ContributorInsightsSummary

    Represents a Contributor Insights summary entry.

  • CreateGlobalSecondaryIndexAction

    Represents a new global secondary index to be added to an existing table.

  • CreateReplicaAction

    Represents a replica to be added.

  • CreateReplicationGroupMemberAction

    Represents a replica to be created.

  • CsvOptions

    Processing options for the CSV file being imported.

  • Delete

    Represents a request to perform a DeleteItem operation.

  • DeleteGlobalSecondaryIndexAction

    Represents a global secondary index to be deleted from an existing table.

  • DeleteReplicaAction

    Represents a replica to be removed.

  • DeleteReplicationGroupMemberAction

    Represents a replica to be deleted.

  • DeleteRequest

    Represents a request to perform a DeleteItem operation on an item.

  • EnableKinesisStreamingConfiguration

    Enables setting the configuration for Kinesis Streaming.

  • Endpoint

    An endpoint information details.

  • ExpectedAttributeValue

    Represents a condition to be compared with an attribute value. This condition can be used with DeleteItem, PutItem, or UpdateItem operations; if the comparison evaluates to true, the operation succeeds; if not, the operation fails. You can use ExpectedAttributeValue in one of two different ways:

    • Use AttributeValueList to specify one or more values to compare against an attribute. Use ComparisonOperator to specify how you want to perform the comparison. If the comparison evaluates to true, then the conditional operation succeeds.

    • Use Value to specify a value that DynamoDB will compare against an attribute. If the values match, then ExpectedAttributeValue evaluates to true and the conditional operation succeeds. Optionally, you can also set Exists to false, indicating that you do not expect to find the attribute value in the table. In this case, the conditional operation succeeds only if the comparison evaluates to false.

    Value and Exists are incompatible with AttributeValueList and ComparisonOperator. Note that if you use both sets of parameters at once, DynamoDB will return a ValidationException exception.

  • ExportDescription

    Represents the properties of the exported table.

  • ExportSummary

    Summary information about an export task.

  • FailureException

    Represents a failure a contributor insights operation.

  • Get

    Specifies an item and related attribute values to retrieve in a TransactGetItem object.

  • GlobalSecondaryIndex

    Represents the properties of a global secondary index.

  • GlobalSecondaryIndexAutoScalingUpdate

    Represents the auto scaling settings of a global secondary index for a global table that will be modified.

  • GlobalSecondaryIndexDescription

    Represents the properties of a global secondary index.

  • GlobalSecondaryIndexInfo

    Represents the properties of a global secondary index for the table when the backup was created.

  • GlobalSecondaryIndexUpdate

    Represents one of the following:

    • A new global secondary index to be added to an existing table.

    • New provisioned throughput parameters for an existing global secondary index.

    • An existing global secondary index to be removed from an existing table.

  • GlobalSecondaryIndexWarmThroughputDescription

    The description of the warm throughput value on a global secondary index.

  • GlobalTable

    Represents the properties of a global table.

  • GlobalTableDescription

    Contains details about the global table.

  • GlobalTableGlobalSecondaryIndexSettingsUpdate

    Represents the settings of a global secondary index for a global table that will be modified.

  • ImportSummary

    Summary information about the source file for the import.

  • ImportTableDescription

    Represents the properties of the table being imported into.

  • IncrementalExportSpecification

    Optional object containing the parameters specific to an incremental export.

  • InputFormatOptions

    The format options for the data that was imported into the target table. There is one value, CsvOption.

  • ItemCollectionMetrics

    Information about item collections, if any, that were affected by the operation. ItemCollectionMetrics is only returned if the request asked for it. If the table does not have any local secondary indexes, this information is not returned in the response.

  • ItemResponse

    Details for the requested item.

  • KeySchemaElement

    Represents a single element of a key schema. A key schema specifies the attributes that make up the primary key of a table, or the key attributes of an index.

    A KeySchemaElement represents exactly one attribute of the primary key. For example, a simple primary key would be represented by one KeySchemaElement (for the partition key). A composite primary key would require one KeySchemaElement for the partition key, and another KeySchemaElement for the sort key.

    A KeySchemaElement must be a scalar, top-level attribute (not a nested attribute). The data type must be one of String, Number, or Binary. The attribute cannot be nested within a List or a Map.

  • KeysAndAttributes

    Represents a set of primary keys and, for each key, the attributes to retrieve from the table.

    For each primary key, you must provide all of the key attributes. For example, with a simple primary key, you only need to provide the partition key. For a composite primary key, you must provide both the partition key and the sort key.

  • KinesisDataStreamDestination

    Describes a Kinesis data stream destination.

  • LocalSecondaryIndex

    Represents the properties of a local secondary index.

  • LocalSecondaryIndexDescription

    Represents the properties of a local secondary index.

  • LocalSecondaryIndexInfo

    Represents the properties of a local secondary index for the table when the backup was created.

  • OnDemandThroughput

    Sets the maximum number of read and write units for the specified on-demand table. If you use this parameter, you must specify MaxReadRequestUnits, MaxWriteRequestUnits, or both.

  • OnDemandThroughputOverride

    Overrides the on-demand throughput settings for this replica table. If you don't specify a value for this parameter, it uses the source table's on-demand throughput settings.

  • ParameterizedStatement

    Represents a PartiQL statement that uses parameters.

  • PointInTimeRecoveryDescription

    The description of the point in time settings applied to the table.

  • PointInTimeRecoverySpecification

    Represents the settings used to enable point in time recovery.

  • Projection

    Represents attributes that are copied (projected) from the table into an index. These are in addition to the primary key attributes and index key attributes, which are automatically projected.

  • ProvisionedThroughput

    Represents the provisioned throughput settings for a specified table or index. The settings can be modified using the UpdateTable operation.

    For current minimum and maximum provisioned throughput values, see Service, Account, and Table Quotas in the Amazon DynamoDB Developer Guide.

  • ProvisionedThroughputDescription

    Represents the provisioned throughput settings for the table, consisting of read and write capacity units, along with data about increases and decreases.

  • ProvisionedThroughputOverride

    Replica-specific provisioned throughput settings. If not specified, uses the source table's provisioned throughput settings.

  • Put

    Represents a request to perform a PutItem operation.

  • PutRequest

    Represents a request to perform a PutItem operation on an item.

  • Replica

    Represents the properties of a replica.

  • ReplicaAutoScalingDescription

    Represents the auto scaling settings of the replica.

  • ReplicaAutoScalingUpdate

    Represents the auto scaling settings of a replica that will be modified.

  • ReplicaDescription

    Contains the details of the replica.

  • ReplicaGlobalSecondaryIndex

    Represents the properties of a replica global secondary index.

  • ReplicaGlobalSecondaryIndexAutoScalingDescription

    Represents the auto scaling configuration for a replica global secondary index.

  • ReplicaGlobalSecondaryIndexAutoScalingUpdate

    Represents the auto scaling settings of a global secondary index for a replica that will be modified.

  • ReplicaGlobalSecondaryIndexDescription

    Represents the properties of a replica global secondary index.

  • ReplicaGlobalSecondaryIndexSettingsDescription

    Represents the properties of a global secondary index.

  • ReplicaGlobalSecondaryIndexSettingsUpdate

    Represents the settings of a global secondary index for a global table that will be modified.

  • ReplicaSettingsDescription

    Represents the properties of a replica.

  • ReplicaSettingsUpdate

    Represents the settings for a global table in a Region that will be modified.

  • ReplicaUpdate

    Represents one of the following:

    • A new replica to be added to an existing global table.

    • New parameters for an existing replica.

    • An existing replica to be removed from an existing global table.

  • ReplicationGroupUpdate

    Represents one of the following:

    • A new replica to be added to an existing regional table or global table. This request invokes the CreateTableReplica action in the destination Region.

    • New parameters for an existing replica. This request invokes the UpdateTable action in the destination Region.

    • An existing replica to be deleted. The request invokes the DeleteTableReplica action in the destination Region, deleting the replica and all if its items in the destination Region.

    When you manually remove a table or global table replica, you do not automatically remove any associated scalable targets, scaling policies, or CloudWatch alarms.

  • RestoreSummary

    Contains details for the restore.

  • S3BucketSource

    The S3 bucket that is being imported from.

  • SourceTableDetails

    Contains the details of the table when the backup was created.

  • SourceTableFeatureDetails

    Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL.

  • SseDescription

    The description of the server-side encryption status on the specified table.

  • SseSpecification

    Represents the settings used to enable server-side encryption.

  • StreamSpecification

    Represents the DynamoDB Streams configuration for a table in DynamoDB.

  • TableAutoScalingDescription

    Represents the auto scaling configuration for a global table.

  • TableClassSummary

    Contains details of the table class.

  • TableCreationParameters

    The parameters for the table created as part of the import operation.

  • TableDescription

    Represents the properties of a table.

  • TableWarmThroughputDescription

    Represents the warm throughput value (in read units per second and write units per second) of the base table.

  • Tag

    Describes a tag. A tag is a key-value pair. You can add up to 50 tags to a single DynamoDB table.

    Amazon Web Services-assigned tag names and values are automatically assigned the aws: prefix, which the user cannot assign. Amazon Web Services-assigned tag names do not count towards the tag limit of 50. User-assigned tag names have the prefix user: in the Cost Allocation Report. You cannot backdate the application of a tag.

    For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in the Amazon DynamoDB Developer Guide.

  • TimeToLiveDescription

    The description of the Time to Live (TTL) status on the specified table.

  • TimeToLiveSpecification

    Represents the settings used to enable or disable Time to Live (TTL) for the specified table.

  • TransactGetItem

    Specifies an item to be retrieved as part of the transaction.

  • TransactWriteItem

    A list of requests that can perform update, put, delete, or check operations on multiple items in one or more tables atomically.

  • Update

    Represents a request to perform an UpdateItem operation.

  • UpdateGlobalSecondaryIndexAction

    Represents the new provisioned throughput settings to be applied to a global secondary index.

  • UpdateKinesisStreamingConfiguration

    Enables updating the configuration for Kinesis Streaming.

  • UpdateReplicationGroupMemberAction

    Represents a replica to be modified.

  • WarmThroughput

    Provides visibility into the number of read and write operations your table or secondary index can instantaneously support. The settings can be modified using the UpdateTable operation to meet the throughput requirements of an upcoming peak event.

  • WriteRequest

    Represents an operation to perform - either DeleteItem or PutItem. You can only request one of these operations, not both, in a single WriteRequest. If you do need to perform both of these operations, you need to provide two separate WriteRequest objects.

Enums§

  • ApproximateCreationDateTimePrecision
    When writing a match expression against ApproximateCreationDateTimePrecision, 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.
  • AttributeAction
    When writing a match expression against AttributeAction, 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.
  • AttributeValue

    Represents the data for an attribute.

    Each attribute value is described as a name-value pair. The name is the data type, and the value is the data itself.

    For more information, see Data Types in the Amazon DynamoDB Developer Guide.

  • BackupStatus
    When writing a match expression against BackupStatus, 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.
  • BackupType
    When writing a match expression against BackupType, 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.
  • BackupTypeFilter
    When writing a match expression against BackupTypeFilter, 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.
  • BatchStatementErrorCodeEnum
    When writing a match expression against BatchStatementErrorCodeEnum, 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.
  • BillingMode
    When writing a match expression against BillingMode, 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.
  • ComparisonOperator
    When writing a match expression against ComparisonOperator, 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.
  • ConditionalOperator
    When writing a match expression against ConditionalOperator, 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.
  • ContinuousBackupsStatus
    When writing a match expression against ContinuousBackupsStatus, 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.
  • ContributorInsightsAction
    When writing a match expression against ContributorInsightsAction, 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.
  • ContributorInsightsStatus
    When writing a match expression against ContributorInsightsStatus, 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.
  • DestinationStatus
    When writing a match expression against DestinationStatus, 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.
  • ExportFormat
    When writing a match expression against ExportFormat, 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.
  • ExportStatus
    When writing a match expression against ExportStatus, 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.
  • ExportType
    When writing a match expression against ExportType, 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.
  • ExportViewType
    When writing a match expression against ExportViewType, 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.
  • GlobalTableStatus
    When writing a match expression against GlobalTableStatus, 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.
  • ImportStatus
    When writing a match expression against ImportStatus, 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.
  • IndexStatus
    When writing a match expression against IndexStatus, 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.
  • InputCompressionType
    When writing a match expression against InputCompressionType, 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.
  • InputFormat
    When writing a match expression against InputFormat, 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.
  • KeyType
    When writing a match expression against KeyType, 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.
  • MultiRegionConsistency
    When writing a match expression against MultiRegionConsistency, 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.
  • PointInTimeRecoveryStatus
    When writing a match expression against PointInTimeRecoveryStatus, 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.
  • ProjectionType
    When writing a match expression against ProjectionType, 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.
  • ReplicaStatus
    When writing a match expression against ReplicaStatus, 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.
  • ReturnConsumedCapacity
    When writing a match expression against ReturnConsumedCapacity, 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.
  • ReturnItemCollectionMetrics
    When writing a match expression against ReturnItemCollectionMetrics, 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.
  • ReturnValue
    When writing a match expression against ReturnValue, 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.
  • ReturnValuesOnConditionCheckFailure
    When writing a match expression against ReturnValuesOnConditionCheckFailure, 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.
  • S3SseAlgorithm
    When writing a match expression against S3SseAlgorithm, 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.
  • ScalarAttributeType
    When writing a match expression against ScalarAttributeType, 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.
  • Select
    When writing a match expression against Select, 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.
  • SseStatus
    When writing a match expression against SseStatus, 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.
  • SseType
    When writing a match expression against SseType, 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.
  • StreamViewType
    When writing a match expression against StreamViewType, 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.
  • TableClass
    When writing a match expression against TableClass, 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.
  • TableStatus
    When writing a match expression against TableStatus, 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.
  • TimeToLiveStatus
    When writing a match expression against TimeToLiveStatus, 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.