Metadata-Version: 2.4
Name: rboto-dynamodb
Version: 0.1.0
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Framework :: AsyncIO
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Programming Language :: Python :: 3.15
Classifier: Programming Language :: Rust
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
Requires-Dist: rboto==0.1.0
License-File: LICENSE
Summary: rboto: async-only, typed Python client for Amazon DynamoDB, powered by Rust. Alpha preview.
Keywords: rboto,aws,dynamodb,asyncio,typing,rust
Home-Page: https://github.com/ferrumio/rboto
Author-email: Leandro Cavalcante Damascena <leandro.damascena@gmail.com>
License-Expression: Apache-2.0
Requires-Python: >=3.12
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Changelog, https://github.com/ferrumio/rboto/releases
Project-URL: Documentation, https://ferrumio.github.io/rboto/guides/dynamodb/
Project-URL: Homepage, https://ferrumio.github.io/rboto/
Project-URL: Issues, https://github.com/ferrumio/rboto/issues
Project-URL: Repository, https://github.com/ferrumio/rboto

<!-- Generated by rboto-codegen. Edit the descriptor, template, or example source. -->
# rboto-dynamodb

rboto is an independent project maintained by [Ferrumio](https://github.com/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.

```bash
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](https://ferrumio.github.io/rboto/getting-started/).

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

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

## Complete signatures

### batch_execute_statement

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


### batch_get_item

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


### batch_write_item

```python
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

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


### create_global_table

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


### create_table

```python
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

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


### delete_item

```python
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

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


### delete_table

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


### describe_backup

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


### describe_continuous_backups

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


### describe_contributor_insights

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


### describe_endpoints

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


### describe_export

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


### describe_global_table

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


### describe_global_table_settings

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


### describe_import

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


### describe_kinesis_streaming_destination

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


### describe_limits

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


### describe_table

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


### describe_table_replica_auto_scaling

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


### describe_time_to_live

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


### disable_kinesis_streaming_destination

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


### enable_kinesis_streaming_destination

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


### execute_statement

```python
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

```python
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

```python
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

```python
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

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


### import_table

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

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


### transact_get_items

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


### transact_write_items

```python
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

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


### update_continuous_backups

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


### update_contributor_insights

```python
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

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


### update_global_table_settings

```python
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

```python
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

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


### update_table

```python
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

```python
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

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


## Links

- [Service guide](https://ferrumio.github.io/rboto/guides/dynamodb/)
- [Repository](https://github.com/ferrumio/rboto)
- [Issues](https://github.com/ferrumio/rboto/issues)
- [Releases](https://github.com/ferrumio/rboto/releases)

Licensed under Apache-2.0.

