rboto-dynamodb

rboto is an independent project maintained by Ferrumio. It is not affiliated with, sponsored by, or endorsed by Amazon Web Services (AWS).

Preview (Alpha). rboto is under active development. APIs may change between releases.

rboto provides an async-only, typed Python client for Amazon DynamoDB, powered by Rust. This package contains DynamoDBClient and 58 operations.

Installation

Requires Python 3.12 or newer and a native wheel for your Python version and platform.

python -m pip install "rboto[dynamodb]"

You can also install rboto-dynamodb directly; it installs the matching rboto package. Only the selected service is installed.

These are the package names to use when a release is available on your package index. If your index has no release yet, follow the source installation instructions.

Usage

Configure credentials through your environment, shared profile, or workload role. The example uses us-east-1; select a region where your service and resources are available. Resource names, identifiers, input files, and model IDs in the example are placeholders to replace with your own.

import asyncio

from rboto import DynamoDBClient
from rboto_dynamodb.types import AttributeValue


async def main() -> None:
    client = DynamoDBClient(region="us-east-1")
    key: dict[str, AttributeValue] = {"pk": {"s": "USER#123"}}
    response = await client.get_item(table_name="users", key=key)
    print(response.item)


if __name__ == "__main__":
    asyncio.run(main())

In an application with an event loop, call await main() instead of asyncio.run(main()). Reuse the client across calls. Constructing a client does not send a request.

API conventions

• Import the client with from rboto import DynamoDBClient.

• Every operation is asynchronous: use await client.method(...).

• Operation arguments are keyword-only and use the Python names listed below.

• Structured inputs use typed dictionaries and tagged unions from rboto_dynamodb.types.

• Regular responses expose typed attributes; response.to_dict() converts them to a dictionary.

• Event-stream responses may be typed dictionaries containing async iterators. Follow the declared return type; consume event streams with async for.

• Byte streams are consumed asynchronously. await stream.read() buffers the complete body; iterate the stream when processing a large response.

• Direct operation calls return one page.

• Use async for page in client.paginators.method(...) for supported paginated operations. Paginators accept the same typed arguments as the corresponding client method.

• Catch modeled exceptions from rboto_dynamodb.exceptions. Their error_code, message, and operation_name identify service failures.

Clients also accept profile, endpoint_url, or shared Session settings. See configuration, errors, and streaming.

Operations

This is the complete operation catalog for this generated package. “Required arguments” lists arguments without defaults in the Python signature. Service-side conditions may require additional arguments. Each method links to its complete signature, including optional arguments. Nested input definitions are in rboto_dynamodb.types; native response definitions are in the package's _native.pyi.

Method	Required arguments	Return type
batch_execute_statement	statements: Sequence[BatchStatementRequest]	BatchExecuteStatementOutput
batch_get_item	request_items: dict[str, KeysAndAttributes]	BatchGetItemOutput
batch_write_item	request_items: dict[str, Sequence[WriteRequest]]	BatchWriteItemOutput
create_backup	table_name: str, backup_name: str	CreateBackupOutput
create_global_table	global_table_name: str, replication_group: Sequence[Replica]	CreateGlobalTableOutput
create_table	table_name: str	CreateTableOutput
delete_backup	backup_arn: str	DeleteBackupOutput
delete_item	table_name: str, key: dict[str, AttributeValue]	DeleteItemOutput
delete_resource_policy	resource_arn: str	DeleteResourcePolicyOutput
delete_table	table_name: str	DeleteTableOutput
describe_backup	backup_arn: str	DescribeBackupOutput
describe_continuous_backups	table_name: str	DescribeContinuousBackupsOutput
describe_contributor_insights	table_name: str	DescribeContributorInsightsOutput
describe_endpoints	None	DescribeEndpointsOutput
describe_export	export_arn: str	DescribeExportOutput
describe_global_table	global_table_name: str	DescribeGlobalTableOutput
describe_global_table_settings	global_table_name: str	DescribeGlobalTableSettingsOutput
describe_import	import_arn: str	DescribeImportOutput
describe_kinesis_streaming_destination	table_name: str	DescribeKinesisStreamingDestinationOutput
describe_limits	None	DescribeLimitsOutput
describe_table	table_name: str	DescribeTableOutput
describe_table_replica_auto_scaling	table_name: str	DescribeTableReplicaAutoScalingOutput
describe_time_to_live	table_name: str	DescribeTimeToLiveOutput
disable_kinesis_streaming_destination	table_name: str, stream_arn: str	DisableKinesisStreamingDestinationOutput
enable_kinesis_streaming_destination	table_name: str, stream_arn: str	EnableKinesisStreamingDestinationOutput
execute_statement	statement: str	ExecuteStatementOutput
execute_transaction	transact_statements: Sequence[ParameterizedStatement]	ExecuteTransactionOutput
export_table_to_point_in_time	table_arn: str, s3_bucket: str	ExportTableToPointInTimeOutput
get_item	table_name: str, key: dict[str, AttributeValue]	GetItemOutput
get_resource_policy	resource_arn: str	GetResourcePolicyOutput
import_table	s3_bucket_source: S3BucketSource, input_format: InputFormat, table_creation_parameters: TableCreationParameters	ImportTableOutput
list_backups	None	ListBackupsOutput
list_contributor_insights	None	ListContributorInsightsOutput
list_exports	None	ListExportsOutput
list_global_tables	None	ListGlobalTablesOutput
list_imports	None	ListImportsOutput
list_tables	None	ListTablesOutput
list_tags_of_resource	resource_arn: str	ListTagsOfResourceOutput
put_item	table_name: str, item: dict[str, AttributeValue]	PutItemOutput
put_resource_policy	resource_arn: str, policy: str	PutResourcePolicyOutput
query	table_name: str	QueryOutput
restore_table_from_backup	target_table_name: str, backup_arn: str	RestoreTableFromBackupOutput
restore_table_to_point_in_time	target_table_name: str	RestoreTableToPointInTimeOutput
scan	table_name: str	ScanOutput
search_vectors	table_name: str, index_name: str, search_vector: Sequence[AttributeValue], top_k: int	SearchVectorsOutput
tag_resource	resource_arn: str, tags: Sequence[Tag]	None
transact_get_items	transact_items: Sequence[TransactGetItem]	TransactGetItemsOutput
transact_write_items	transact_items: Sequence[TransactWriteItem]	TransactWriteItemsOutput
untag_resource	resource_arn: str, tag_keys: Sequence[str]	None
update_continuous_backups	table_name: str, point_in_time_recovery_specification: PointInTimeRecoverySpecification	UpdateContinuousBackupsOutput
update_contributor_insights	table_name: str, contributor_insights_action: ContributorInsightsAction	UpdateContributorInsightsOutput
update_global_table	global_table_name: str, replica_updates: Sequence[ReplicaUpdate]	UpdateGlobalTableOutput
update_global_table_settings	global_table_name: str	UpdateGlobalTableSettingsOutput
update_item	table_name: str, key: dict[str, AttributeValue]	UpdateItemOutput
update_kinesis_streaming_destination	table_name: str, stream_arn: str	UpdateKinesisStreamingDestinationOutput
update_table	table_name: str	UpdateTableOutput
update_table_replica_auto_scaling	table_name: str	UpdateTableReplicaAutoScalingOutput
update_time_to_live	table_name: str, time_to_live_specification: TimeToLiveSpecification	UpdateTimeToLiveOutput

Complete signatures

batch_execute_statement

async def batch_execute_statement(
    *,
    statements: Sequence[BatchStatementRequest],
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
) -> BatchExecuteStatementOutput: ...

batch_get_item

async def batch_get_item(
    *,
    request_items: dict[str, KeysAndAttributes],
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
) -> BatchGetItemOutput: ...

batch_write_item

async def batch_write_item(
    *,
    request_items: dict[str, Sequence[WriteRequest]],
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    return_item_collection_metrics: ReturnItemCollectionMetrics | None = None,
) -> BatchWriteItemOutput: ...

create_backup

async def create_backup(
    *,
    table_name: str,
    backup_name: str,
) -> CreateBackupOutput: ...

create_global_table

async def create_global_table(
    *,
    global_table_name: str,
    replication_group: Sequence[Replica],
) -> CreateGlobalTableOutput: ...

create_table

async def create_table(
    *,
    table_name: str,
    attribute_definitions: Sequence[AttributeDefinition] | None = None,
    key_schema: Sequence[KeySchemaElement] | None = None,
    local_secondary_indexes: Sequence[LocalSecondaryIndex] | None = None,
    global_secondary_indexes: Sequence[GlobalSecondaryIndex] | None = None,
    billing_mode: BillingMode | None = None,
    provisioned_throughput: ProvisionedThroughput | None = None,
    stream_specification: StreamSpecification | None = None,
    sse_specification: SSESpecification | None = None,
    tags: Sequence[Tag] | None = None,
    table_class: TableClass | None = None,
    deletion_protection_enabled: bool | None = None,
    warm_throughput: WarmThroughput | None = None,
    resource_policy: str | None = None,
    on_demand_throughput: OnDemandThroughput | None = None,
    global_table_source_arn: str | None = None,
    global_table_settings_replication_mode: GlobalTableSettingsReplicationMode | None = None,
    vector_indexes: Sequence[VectorIndex] | None = None,
) -> CreateTableOutput: ...

delete_backup

async def delete_backup(
    *,
    backup_arn: str,
) -> DeleteBackupOutput: ...

delete_item

async def delete_item(
    *,
    table_name: str,
    key: dict[str, AttributeValue],
    expected: dict[str, ExpectedAttributeValue] | None = None,
    conditional_operator: ConditionalOperator | None = None,
    return_values: ReturnValue | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    return_item_collection_metrics: ReturnItemCollectionMetrics | None = None,
    condition_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
    return_values_on_condition_check_failure: ReturnValuesOnConditionCheckFailure | None = None,
) -> DeleteItemOutput: ...

delete_resource_policy

async def delete_resource_policy(
    *,
    resource_arn: str,
    expected_revision_id: str | None = None,
) -> DeleteResourcePolicyOutput: ...

delete_table

async def delete_table(
    *,
    table_name: str,
) -> DeleteTableOutput: ...

describe_backup

async def describe_backup(
    *,
    backup_arn: str,
) -> DescribeBackupOutput: ...

describe_continuous_backups

async def describe_continuous_backups(
    *,
    table_name: str,
) -> DescribeContinuousBackupsOutput: ...

describe_contributor_insights

async def describe_contributor_insights(
    *,
    table_name: str,
    index_name: str | None = None,
) -> DescribeContributorInsightsOutput: ...

describe_endpoints

async def describe_endpoints() -> DescribeEndpointsOutput: ...

describe_export

async def describe_export(
    *,
    export_arn: str,
) -> DescribeExportOutput: ...

describe_global_table

async def describe_global_table(
    *,
    global_table_name: str,
) -> DescribeGlobalTableOutput: ...

describe_global_table_settings

async def describe_global_table_settings(
    *,
    global_table_name: str,
) -> DescribeGlobalTableSettingsOutput: ...

describe_import

async def describe_import(
    *,
    import_arn: str,
) -> DescribeImportOutput: ...

describe_kinesis_streaming_destination

async def describe_kinesis_streaming_destination(
    *,
    table_name: str,
) -> DescribeKinesisStreamingDestinationOutput: ...

describe_limits

async def describe_limits() -> DescribeLimitsOutput: ...

describe_table

async def describe_table(
    *,
    table_name: str,
) -> DescribeTableOutput: ...

describe_table_replica_auto_scaling

async def describe_table_replica_auto_scaling(
    *,
    table_name: str,
) -> DescribeTableReplicaAutoScalingOutput: ...

describe_time_to_live

async def describe_time_to_live(
    *,
    table_name: str,
) -> DescribeTimeToLiveOutput: ...

disable_kinesis_streaming_destination

async def disable_kinesis_streaming_destination(
    *,
    table_name: str,
    stream_arn: str,
    enable_kinesis_streaming_configuration: EnableKinesisStreamingConfiguration | None = None,
) -> DisableKinesisStreamingDestinationOutput: ...

enable_kinesis_streaming_destination

async def enable_kinesis_streaming_destination(
    *,
    table_name: str,
    stream_arn: str,
    enable_kinesis_streaming_configuration: EnableKinesisStreamingConfiguration | None = None,
) -> EnableKinesisStreamingDestinationOutput: ...

execute_statement

async def execute_statement(
    *,
    statement: str,
    parameters: Sequence[AttributeValue] | None = None,
    consistent_read: bool | None = None,
    next_token: str | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    limit: int | None = None,
    return_values_on_condition_check_failure: ReturnValuesOnConditionCheckFailure | None = None,
) -> ExecuteStatementOutput: ...

execute_transaction

async def execute_transaction(
    *,
    transact_statements: Sequence[ParameterizedStatement],
    client_request_token: str | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
) -> ExecuteTransactionOutput: ...

export_table_to_point_in_time

async def export_table_to_point_in_time(
    *,
    table_arn: str,
    s3_bucket: str,
    export_time: str | None = None,
    client_token: str | None = None,
    s3_bucket_owner: str | None = None,
    s3_prefix: str | None = None,
    s3_sse_algorithm: S3SseAlgorithm | None = None,
    s3_sse_kms_key_id: str | None = None,
    export_format: ExportFormat | None = None,
    export_type: ExportType | None = None,
    incremental_export_specification: IncrementalExportSpecification | None = None,
    filter_specification: FilterSpecification | None = None,
) -> ExportTableToPointInTimeOutput: ...

get_item

async def get_item(
    *,
    table_name: str,
    key: dict[str, AttributeValue],
    attributes_to_get: Sequence[str] | None = None,
    consistent_read: bool | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    projection_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
) -> GetItemOutput: ...

get_resource_policy

async def get_resource_policy(
    *,
    resource_arn: str,
) -> GetResourcePolicyOutput: ...

import_table

async def import_table(
    *,
    s3_bucket_source: S3BucketSource,
    input_format: InputFormat,
    table_creation_parameters: TableCreationParameters,
    client_token: str | None = None,
    input_format_options: InputFormatOptions | None = None,
    input_compression_type: InputCompressionType | None = None,
) -> ImportTableOutput: ...

list_backups

async def list_backups(
    *,
    table_name: str | None = None,
    limit: int | None = None,
    time_range_lower_bound: str | None = None,
    time_range_upper_bound: str | None = None,
    exclusive_start_backup_arn: str | None = None,
    backup_type: BackupTypeFilter | None = None,
) -> ListBackupsOutput: ...

Also available as client.paginators.list_backups(...), returning an async iterator of the response type above.

list_contributor_insights

async def list_contributor_insights(
    *,
    table_name: str | None = None,
    next_token: str | None = None,
    max_results: int | None = None,
) -> ListContributorInsightsOutput: ...

Also available as client.paginators.list_contributor_insights(...), returning an async iterator of the response type above.

list_exports

async def list_exports(
    *,
    table_arn: str | None = None,
    max_results: int | None = None,
    next_token: str | None = None,
) -> ListExportsOutput: ...

Also available as client.paginators.list_exports(...), returning an async iterator of the response type above.

list_global_tables

async def list_global_tables(
    *,
    exclusive_start_global_table_name: str | None = None,
    limit: int | None = None,
    region_name: str | None = None,
) -> ListGlobalTablesOutput: ...

list_imports

async def list_imports(
    *,
    table_arn: str | None = None,
    page_size: int | None = None,
    next_token: str | None = None,
) -> ListImportsOutput: ...

Also available as client.paginators.list_imports(...), returning an async iterator of the response type above.

list_tables

async def list_tables(
    *,
    exclusive_start_table_name: str | None = None,
    limit: int | None = None,
) -> ListTablesOutput: ...

Also available as client.paginators.list_tables(...), returning an async iterator of the response type above.

list_tags_of_resource

async def list_tags_of_resource(
    *,
    resource_arn: str,
    next_token: str | None = None,
) -> ListTagsOfResourceOutput: ...

Also available as client.paginators.list_tags_of_resource(...), returning an async iterator of the response type above.

put_item

async def put_item(
    *,
    table_name: str,
    item: dict[str, AttributeValue],
    expected: dict[str, ExpectedAttributeValue] | None = None,
    return_values: ReturnValue | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    return_item_collection_metrics: ReturnItemCollectionMetrics | None = None,
    conditional_operator: ConditionalOperator | None = None,
    condition_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
    return_values_on_condition_check_failure: ReturnValuesOnConditionCheckFailure | None = None,
) -> PutItemOutput: ...

put_resource_policy

async def put_resource_policy(
    *,
    resource_arn: str,
    policy: str,
    expected_revision_id: str | None = None,
    confirm_remove_self_resource_access: bool | None = None,
) -> PutResourcePolicyOutput: ...

query

async def query(
    *,
    table_name: str,
    index_name: str | None = None,
    select: Select | None = None,
    attributes_to_get: Sequence[str] | None = None,
    limit: int | None = None,
    consistent_read: bool | None = None,
    key_conditions: dict[str, Condition] | None = None,
    query_filter: dict[str, Condition] | None = None,
    conditional_operator: ConditionalOperator | None = None,
    scan_index_forward: bool | None = None,
    exclusive_start_key: dict[str, AttributeValue] | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    projection_expression: str | None = None,
    filter_expression: str | None = None,
    key_condition_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
) -> QueryOutput: ...

Also available as client.paginators.query(...), returning an async iterator of the response type above.

restore_table_from_backup

async def restore_table_from_backup(
    *,
    target_table_name: str,
    backup_arn: str,
    billing_mode_override: BillingMode | None = None,
    global_secondary_index_override: Sequence[GlobalSecondaryIndex] | None = None,
    local_secondary_index_override: Sequence[LocalSecondaryIndex] | None = None,
    provisioned_throughput_override: ProvisionedThroughput | None = None,
    on_demand_throughput_override: OnDemandThroughput | None = None,
    sse_specification_override: SSESpecification | None = None,
    vector_index_override: Sequence[VectorIndex] | None = None,
) -> RestoreTableFromBackupOutput: ...

restore_table_to_point_in_time

async def restore_table_to_point_in_time(
    *,
    target_table_name: str,
    source_table_arn: str | None = None,
    source_table_name: str | None = None,
    use_latest_restorable_time: bool | None = None,
    restore_date_time: str | None = None,
    billing_mode_override: BillingMode | None = None,
    global_secondary_index_override: Sequence[GlobalSecondaryIndex] | None = None,
    local_secondary_index_override: Sequence[LocalSecondaryIndex] | None = None,
    provisioned_throughput_override: ProvisionedThroughput | None = None,
    on_demand_throughput_override: OnDemandThroughput | None = None,
    sse_specification_override: SSESpecification | None = None,
    vector_index_override: Sequence[VectorIndex] | None = None,
) -> RestoreTableToPointInTimeOutput: ...

scan

async def scan(
    *,
    table_name: str,
    index_name: str | None = None,
    attributes_to_get: Sequence[str] | None = None,
    limit: int | None = None,
    select: Select | None = None,
    scan_filter: dict[str, Condition] | None = None,
    conditional_operator: ConditionalOperator | None = None,
    exclusive_start_key: dict[str, AttributeValue] | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    total_segments: int | None = None,
    segment: int | None = None,
    projection_expression: str | None = None,
    filter_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
    consistent_read: bool | None = None,
) -> ScanOutput: ...

Also available as client.paginators.scan(...), returning an async iterator of the response type above.

search_vectors

async def search_vectors(
    *,
    table_name: str,
    index_name: str,
    search_vector: Sequence[AttributeValue],
    top_k: int,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
    projection_expression: str | None = None,
    search_condition_expression: str | None = None,
) -> SearchVectorsOutput: ...

tag_resource

async def tag_resource(
    *,
    resource_arn: str,
    tags: Sequence[Tag],
) -> None: ...

transact_get_items

async def transact_get_items(
    *,
    transact_items: Sequence[TransactGetItem],
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
) -> TransactGetItemsOutput: ...

transact_write_items

async def transact_write_items(
    *,
    transact_items: Sequence[TransactWriteItem],
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    return_item_collection_metrics: ReturnItemCollectionMetrics | None = None,
    client_request_token: str | None = None,
) -> TransactWriteItemsOutput: ...

untag_resource

async def untag_resource(
    *,
    resource_arn: str,
    tag_keys: Sequence[str],
) -> None: ...

update_continuous_backups

async def update_continuous_backups(
    *,
    table_name: str,
    point_in_time_recovery_specification: PointInTimeRecoverySpecification,
) -> UpdateContinuousBackupsOutput: ...

update_contributor_insights

async def update_contributor_insights(
    *,
    table_name: str,
    contributor_insights_action: ContributorInsightsAction,
    index_name: str | None = None,
    contributor_insights_mode: ContributorInsightsMode | None = None,
) -> UpdateContributorInsightsOutput: ...

update_global_table

async def update_global_table(
    *,
    global_table_name: str,
    replica_updates: Sequence[ReplicaUpdate],
) -> UpdateGlobalTableOutput: ...

update_global_table_settings

async def update_global_table_settings(
    *,
    global_table_name: str,
    global_table_billing_mode: BillingMode | None = None,
    global_table_provisioned_write_capacity_units: int | None = None,
    global_table_provisioned_write_capacity_auto_scaling_settings_update: AutoScalingSettingsUpdate | None = None,
    global_table_global_secondary_index_settings_update: Sequence[GlobalTableGlobalSecondaryIndexSettingsUpdate] | None = None,
    replica_settings_update: Sequence[ReplicaSettingsUpdate] | None = None,
) -> UpdateGlobalTableSettingsOutput: ...

update_item

async def update_item(
    *,
    table_name: str,
    key: dict[str, AttributeValue],
    attribute_updates: dict[str, AttributeValueUpdate] | None = None,
    expected: dict[str, ExpectedAttributeValue] | None = None,
    conditional_operator: ConditionalOperator | None = None,
    return_values: ReturnValue | None = None,
    return_consumed_capacity: ReturnConsumedCapacity | None = None,
    return_item_collection_metrics: ReturnItemCollectionMetrics | None = None,
    update_expression: str | None = None,
    condition_expression: str | None = None,
    expression_attribute_names: dict[str, str] | None = None,
    expression_attribute_values: dict[str, AttributeValue] | None = None,
    return_values_on_condition_check_failure: ReturnValuesOnConditionCheckFailure | None = None,
) -> UpdateItemOutput: ...

update_kinesis_streaming_destination

async def update_kinesis_streaming_destination(
    *,
    table_name: str,
    stream_arn: str,
    update_kinesis_streaming_configuration: UpdateKinesisStreamingConfiguration | None = None,
) -> UpdateKinesisStreamingDestinationOutput: ...

update_table

async def update_table(
    *,
    table_name: str,
    attribute_definitions: Sequence[AttributeDefinition] | None = None,
    billing_mode: BillingMode | None = None,
    provisioned_throughput: ProvisionedThroughput | None = None,
    global_secondary_index_updates: Sequence[GlobalSecondaryIndexUpdate] | None = None,
    stream_specification: StreamSpecification | None = None,
    sse_specification: SSESpecification | None = None,
    replica_updates: Sequence[ReplicationGroupUpdate] | None = None,
    table_class: TableClass | None = None,
    deletion_protection_enabled: bool | None = None,
    multi_region_consistency: MultiRegionConsistency | None = None,
    global_table_witness_updates: Sequence[GlobalTableWitnessGroupUpdate] | None = None,
    on_demand_throughput: OnDemandThroughput | None = None,
    warm_throughput: WarmThroughput | None = None,
    global_table_settings_replication_mode: GlobalTableSettingsReplicationMode | None = None,
    disassociation_protection_enabled: bool | None = None,
    vector_index_updates: Sequence[VectorIndexUpdate] | None = None,
) -> UpdateTableOutput: ...

update_table_replica_auto_scaling

async def update_table_replica_auto_scaling(
    *,
    table_name: str,
    global_secondary_index_updates: Sequence[GlobalSecondaryIndexAutoScalingUpdate] | None = None,
    provisioned_write_capacity_auto_scaling_update: AutoScalingSettingsUpdate | None = None,
    replica_updates: Sequence[ReplicaAutoScalingUpdate] | None = None,
) -> UpdateTableReplicaAutoScalingOutput: ...

update_time_to_live

async def update_time_to_live(
    *,
    table_name: str,
    time_to_live_specification: TimeToLiveSpecification,
) -> UpdateTimeToLiveOutput: ...

Links

• Service guide
• Repository
• Issues
• Releases

Licensed under Apache-2.0.