diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/aws_sdk_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/aws_sdk_to_dafny.py
new file mode 100644
index 000000000..c58eacb37
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/aws_sdk_to_dafny.py
@@ -0,0 +1,113 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+)
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+
+
+def com_amazonaws_dynamodb_AttributeValue(native_input):
+ if "S" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_S(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["S"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "N" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_N(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["N"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "B" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_B(Seq(native_input["B"]))
+ elif "SS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_SS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["SS"]
+ ]
+ )
+ )
+ elif "NS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["NS"]
+ ]
+ )
+ )
+ elif "BS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BS(Seq([Seq(list_element) for list_element in native_input["BS"]]))
+ elif "M" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_M(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["M"].items()
+ }
+ )
+ )
+ elif "L" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_L(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["L"]
+ ]
+ )
+ )
+ elif "NULL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NULL(native_input["NULL"])
+ elif "BOOL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BOOL(native_input["BOOL"])
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return AttributeValue_union_value
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/client.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/client.py
new file mode 100644
index 000000000..93914b228
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/client.py
@@ -0,0 +1,348 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ IDynamoDbEncryptionClient,
+)
+from typing import Callable, TypeVar, cast
+
+from .config import Config, DynamoDbEncryptionConfig
+from .dafny_protocol import DafnyRequest, DafnyResponse
+from .plugin import set_config_impl
+from smithy_python.exceptions import SmithyRetryException
+from smithy_python.interfaces.interceptor import Interceptor, InterceptorContext
+from smithy_python.interfaces.retries import RetryErrorInfo, RetryErrorType
+
+from .config import Plugin
+from .deserialize import (
+ _deserialize_create_dynamo_db_encryption_branch_key_id_supplier,
+ _deserialize_get_encrypted_data_key_description,
+)
+from .errors import ServiceError
+from .models import (
+ CreateDynamoDbEncryptionBranchKeyIdSupplierInput,
+ CreateDynamoDbEncryptionBranchKeyIdSupplierOutput,
+ GetEncryptedDataKeyDescriptionInput,
+ GetEncryptedDataKeyDescriptionOutput,
+)
+from .serialize import (
+ _serialize_create_dynamo_db_encryption_branch_key_id_supplier,
+ _serialize_get_encrypted_data_key_description,
+)
+
+
+Input = TypeVar("Input")
+Output = TypeVar("Output")
+
+
+class DynamoDbEncryption:
+ """Client for DynamoDbEncryption.
+
+ :param config: Configuration for the client.
+ """
+
+ def __init__(
+ self,
+ config: DynamoDbEncryptionConfig | None = None,
+ dafny_client: IDynamoDbEncryptionClient | None = None,
+ ):
+ if config is None:
+ self._config = Config()
+ else:
+ self._config = config
+
+ client_plugins: list[Plugin] = [
+ set_config_impl,
+ ]
+
+ for plugin in client_plugins:
+ plugin(self._config)
+
+ if dafny_client is not None:
+ self._config.dafnyImplInterface.impl = dafny_client
+
+ def create_dynamo_db_encryption_branch_key_id_supplier(
+ self, input: CreateDynamoDbEncryptionBranchKeyIdSupplierInput
+ ) -> CreateDynamoDbEncryptionBranchKeyIdSupplierOutput:
+ """Create a Branch Key Supplier for use with the Hierarchical Keyring
+ that decides what Branch Key to use based on the primary key of the
+ DynamoDB item being read or written.
+
+ :param input: Inputs for creating a Branch Key Supplier from a
+ DynamoDB Key Branch Key Id Supplier
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_create_dynamo_db_encryption_branch_key_id_supplier,
+ deserialize=_deserialize_create_dynamo_db_encryption_branch_key_id_supplier,
+ config=self._config,
+ operation_name="CreateDynamoDbEncryptionBranchKeyIdSupplier",
+ )
+
+ def get_encrypted_data_key_description(
+ self, input: GetEncryptedDataKeyDescriptionInput
+ ) -> GetEncryptedDataKeyDescriptionOutput:
+ """Returns encrypted data key description.
+
+ :param input: Input for getting encrypted data key description.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_get_encrypted_data_key_description,
+ deserialize=_deserialize_get_encrypted_data_key_description,
+ config=self._config,
+ operation_name="GetEncryptedDataKeyDescription",
+ )
+
+ def _execute_operation(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ try:
+ return self._handle_execution(input, plugins, serialize, deserialize, config, operation_name)
+ except Exception as e:
+ # Make sure every exception that we throw is an instance of ServiceError so
+ # customers can reliably catch everything we throw.
+ if not isinstance(e, ServiceError):
+ raise ServiceError(e) from e
+ raise e
+
+ def _handle_execution(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ context: InterceptorContext[Input, None, None, None] = InterceptorContext(
+ request=input,
+ response=None,
+ transport_request=None,
+ transport_response=None,
+ )
+ try:
+ _client_interceptors = config.interceptors
+ except AttributeError:
+ config.interceptors = []
+ _client_interceptors = config.interceptors
+ client_interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+ interceptors = client_interceptors
+
+ try:
+ # Step 1a: Invoke read_before_execution on client-level interceptors
+ for interceptor in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 1b: Run operation-level plugins
+ for plugin in plugins:
+ plugin(config)
+
+ _client_interceptors = config.interceptors
+ interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+
+ # Step 1c: Invoke the read_before_execution hooks on newly added
+ # interceptors.
+ for interceptor in interceptors:
+ if interceptor not in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 2: Invoke the modify_before_serialization hooks
+ for interceptor in interceptors:
+ context._request = interceptor.modify_before_serialization(context)
+
+ # Step 3: Invoke the read_before_serialization hooks
+ for interceptor in interceptors:
+ interceptor.read_before_serialization(context)
+
+ # Step 4: Serialize the request
+ context_with_transport_request = cast(InterceptorContext[Input, None, DafnyRequest, None], context)
+ context_with_transport_request._transport_request = serialize(
+ context_with_transport_request.request, config
+ )
+
+ # Step 5: Invoke read_after_serialization
+ for interceptor in interceptors:
+ interceptor.read_after_serialization(context_with_transport_request)
+
+ # Step 6: Invoke modify_before_retry_loop
+ for interceptor in interceptors:
+ context_with_transport_request._transport_request = interceptor.modify_before_retry_loop(
+ context_with_transport_request
+ )
+
+ # Step 7: Acquire the retry token.
+ retry_strategy = config.retry_strategy
+ retry_token = retry_strategy.acquire_initial_retry_token()
+
+ while True:
+ # Make an attempt, creating a copy of the context so we don't pass
+ # around old data.
+ context_with_response = self._handle_attempt(
+ deserialize,
+ interceptors,
+ context_with_transport_request.copy(),
+ config,
+ operation_name,
+ )
+
+ # We perform this type-ignored re-assignment because `context` needs
+ # to point at the latest context so it can be generically handled
+ # later on. This is only an issue here because we've created a copy,
+ # so we're no longer simply pointing at the same object in memory
+ # with different names and type hints. It is possible to address this
+ # without having to fall back to the type ignore, but it would impose
+ # unnecessary runtime costs.
+ context = context_with_response # type: ignore
+
+ if isinstance(context_with_response.response, Exception):
+ # Step 7u: Reacquire retry token if the attempt failed
+ try:
+ retry_token = retry_strategy.refresh_retry_token_for_retry(
+ token_to_renew=retry_token,
+ error_info=RetryErrorInfo(
+ # TODO: Determine the error type.
+ error_type=RetryErrorType.CLIENT_ERROR,
+ ),
+ )
+ except SmithyRetryException:
+ raise context_with_response.response
+ else:
+ # Step 8: Invoke record_success
+ retry_strategy.record_success(token=retry_token)
+ break
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request will have been definitively set, and
+ # The response will be set either with the modeled output or an exception. The
+ # transport_request and transport_response may be set or None.
+ execution_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_execution(interceptors, execution_context)
+
+ def _handle_attempt(
+ self,
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, None, DafnyRequest, None],
+ config: Config,
+ operation_name: str,
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ try:
+ # Step 7a: Invoke read_before_attempt
+ for interceptor in interceptors:
+ interceptor.read_before_attempt(context)
+
+ # Step 7m: Involve client Dafny impl
+ if config.dafnyImplInterface.impl is None:
+ raise Exception("No impl found on the operation config.")
+
+ context_with_response = cast(InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context)
+
+ context_with_response._transport_response = config.dafnyImplInterface.handle_request(
+ input=context_with_response.transport_request
+ )
+
+ # Step 7n: Invoke read_after_transmit
+ for interceptor in interceptors:
+ interceptor.read_after_transmit(context_with_response)
+
+ # Step 7o: Invoke modify_before_deserialization
+ for interceptor in interceptors:
+ context_with_response._transport_response = interceptor.modify_before_deserialization(
+ context_with_response
+ )
+
+ # Step 7p: Invoke read_before_deserialization
+ for interceptor in interceptors:
+ interceptor.read_before_deserialization(context_with_response)
+
+ # Step 7q: deserialize
+ context_with_output = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse],
+ context_with_response,
+ )
+ context_with_output._response = deserialize(context_with_output._transport_response, config)
+
+ # Step 7r: Invoke read_after_deserialization
+ for interceptor in interceptors:
+ interceptor.read_after_deserialization(context_with_output)
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request and transport_request have definitively been set,
+ # the response is either set or an exception, and the transport_resposne is either set or
+ # None. This will also be true after _finalize_attempt because there is no opportunity
+ # there to set the transport_response.
+ attempt_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_attempt(interceptors, attempt_context)
+
+ def _finalize_attempt(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ # Step 7s: Invoke modify_before_attempt_completion
+ try:
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_attempt_completion(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 7t: Invoke read_after_attempt
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_attempt(context)
+ except Exception as e:
+ context._response = e
+
+ return context
+
+ def _finalize_execution(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ ) -> Output:
+ try:
+ # Step 9: Invoke modify_before_completion
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_completion(context)
+
+ except Exception as e:
+ context._response = e
+
+ # Step 11: Invoke read_after_execution
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_execution(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 12: Return / throw
+ if isinstance(context.response, Exception):
+ raise context.response
+
+ # We may want to add some aspects of this context to the output types so we can
+ # return it to the end-users.
+ return context.response
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/config.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/config.py
new file mode 100644
index 000000000..788f97a41
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/config.py
@@ -0,0 +1,92 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ DynamoDbEncryptionConfig_DynamoDbEncryptionConfig as DafnyDynamoDbEncryptionConfig,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, TypeAlias
+
+from .dafnyImplInterface import DafnyImplInterface
+from smithy_python._private.retries import SimpleRetryStrategy
+from smithy_python.interfaces.retries import RetryStrategy
+
+
+_ServiceInterceptor = Any
+
+
+@dataclass(init=False)
+class Config:
+ """Configuration for DynamoDbEncryption."""
+
+ interceptors: list[_ServiceInterceptor]
+ retry_strategy: RetryStrategy
+ dafnyImplInterface: DafnyImplInterface | None
+
+ def __init__(
+ self,
+ *,
+ interceptors: list[_ServiceInterceptor] | None = None,
+ retry_strategy: RetryStrategy | None = None,
+ dafnyImplInterface: DafnyImplInterface | None = None,
+ ):
+ """Constructor.
+
+ :param interceptors: The list of interceptors, which are hooks
+ that are called during the execution of a request.
+ :param retry_strategy: The retry strategy for issuing retry
+ tokens and computing retry delays.
+ :param dafnyImplInterface:
+ """
+ self.interceptors = interceptors or []
+ self.retry_strategy = retry_strategy or SimpleRetryStrategy()
+ self.dafnyImplInterface = dafnyImplInterface
+
+
+# A callable that allows customizing the config object on each request.
+Plugin: TypeAlias = Callable[[Config], None]
+
+
+class DynamoDbEncryptionConfig(Config):
+ def __init__(
+ self,
+ ):
+ """Constructor for DynamoDbEncryptionConfig."""
+ super().__init__()
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbEncryptionConfig to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbEncryptionConfig":
+ """Creates a DynamoDbEncryptionConfig from a dictionary."""
+ return DynamoDbEncryptionConfig()
+
+ def __repr__(self) -> str:
+ result = "DynamoDbEncryptionConfig("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, DynamoDbEncryptionConfig)
+
+
+def dafny_config_to_smithy_config(dafny_config) -> DynamoDbEncryptionConfig:
+ """Converts the provided Dafny shape for this localService's config into
+ the corresponding Smithy-modelled shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbEncryptionConfig(
+ dafny_config
+ )
+
+
+def smithy_config_to_dafny_config(smithy_config) -> DafnyDynamoDbEncryptionConfig:
+ """Converts the provided Smithy-modelled shape for this localService's
+ config into the corresponding Dafny shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbEncryptionConfig(
+ smithy_config
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafnyImplInterface.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafnyImplInterface.py
new file mode 100644
index 000000000..2f25de773
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafnyImplInterface.py
@@ -0,0 +1,34 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbEncryption import (
+ DynamoDbEncryptionClient,
+)
+from .dafny_protocol import DafnyRequest
+
+
+class DafnyImplInterface:
+ impl: DynamoDbEncryptionClient | None = None
+
+ # operation_map cannot be created at dafnyImplInterface create time,
+ # as the map's values reference values inside `self.impl`,
+ # and impl is only populated at runtime.
+ # Accessing these before impl is populated results in an error.
+ # At runtime, the map is populated once and cached.
+ operation_map = None
+
+ def handle_request(self, input: DafnyRequest):
+ if self.operation_map is None:
+ self.operation_map = {
+ "CreateDynamoDbEncryptionBranchKeyIdSupplier": self.impl.CreateDynamoDbEncryptionBranchKeyIdSupplier,
+ "GetEncryptedDataKeyDescription": self.impl.GetEncryptedDataKeyDescription,
+ }
+
+ # This logic is where a typical Smithy client would expect the "server" to be.
+ # This code can be thought of as logic our Dafny "server" uses
+ # to route incoming client requests to the correct request handler code.
+ if input.dafny_operation_input is None:
+ return self.operation_map[input.operation_name]()
+ else:
+ return self.operation_map[input.operation_name](input.dafny_operation_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_protocol.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_protocol.py
new file mode 100644
index 000000000..da77ee605
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_protocol.py
@@ -0,0 +1,33 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ CreateDynamoDbEncryptionBranchKeyIdSupplierInput_CreateDynamoDbEncryptionBranchKeyIdSupplierInput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierInput,
+ GetEncryptedDataKeyDescriptionInput_GetEncryptedDataKeyDescriptionInput as DafnyGetEncryptedDataKeyDescriptionInput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+from typing import Union
+
+
+class DafnyRequest:
+ operation_name: str
+
+ # dafny_operation_input can take on any one of the types
+ # of the input values passed to the Dafny implementation
+ dafny_operation_input: Union[
+ DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierInput,
+ DafnyGetEncryptedDataKeyDescriptionInput,
+ ]
+
+ def __init__(self, operation_name, dafny_operation_input):
+ self.operation_name = operation_name
+ self.dafny_operation_input = dafny_operation_input
+
+
+class DafnyResponse(Wrappers.Result):
+ def __init__(self):
+ super().__init__(self)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_aws_sdk.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_aws_sdk.py
new file mode 100644
index 000000000..9aca0964e
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_aws_sdk.py
@@ -0,0 +1,75 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+)
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+
+
+def com_amazonaws_dynamodb_AttributeValue(dafny_input):
+ # Convert AttributeValue
+ if isinstance(dafny_input, AttributeValue_S):
+ AttributeValue_union_value = {
+ "S": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.S).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_N):
+ AttributeValue_union_value = {
+ "N": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.N).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_B):
+ AttributeValue_union_value = {"B": bytes(dafny_input.B)}
+ elif isinstance(dafny_input, AttributeValue_SS):
+ AttributeValue_union_value = {
+ "SS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.SS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NS):
+ AttributeValue_union_value = {
+ "NS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.NS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_BS):
+ AttributeValue_union_value = {"BS": [bytes(list_element) for list_element in dafny_input.BS]}
+ elif isinstance(dafny_input, AttributeValue_M):
+ AttributeValue_union_value = {
+ "M": {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.M.items
+ }
+ }
+ elif isinstance(dafny_input, AttributeValue_L):
+ AttributeValue_union_value = {
+ "L": [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.L
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NULL):
+ AttributeValue_union_value = {"NULL": dafny_input.NULL}
+ elif isinstance(dafny_input, AttributeValue_BOOL):
+ AttributeValue_union_value = {"BOOL": dafny_input.BOOL}
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return AttributeValue_union_value
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_smithy.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_smithy.py
new file mode 100644
index 000000000..9542044ab
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_smithy.py
@@ -0,0 +1,820 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ BeaconKeySource_multi,
+ BeaconKeySource_single,
+ BeaconStyle_asSet,
+ BeaconStyle_partOnly,
+ BeaconStyle_shared,
+ BeaconStyle_sharedSet,
+ GetEncryptedDataKeyDescriptionUnion_header,
+ GetEncryptedDataKeyDescriptionUnion_item,
+ LegacyPolicy_FORBID__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT,
+ LegacyPolicy_FORBID__LEGACY__ENCRYPT__FORBID__LEGACY__DECRYPT,
+ LegacyPolicy_FORCE__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT,
+ PlaintextOverride_FORBID__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ,
+ PlaintextOverride_FORBID__PLAINTEXT__WRITE__FORBID__PLAINTEXT__READ,
+ PlaintextOverride_FORCE__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ,
+ VirtualTransform_insert,
+ VirtualTransform_lower,
+ VirtualTransform_prefix,
+ VirtualTransform_segment,
+ VirtualTransform_segments,
+ VirtualTransform_substring,
+ VirtualTransform_suffix,
+ VirtualTransform_upper,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyInput(
+ ddb_key={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ddbKey.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyOutput(
+ branch_key_id=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.branchKeyId).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbKeyBranchKeyIdSupplierReference(
+ dafny_input,
+):
+ if hasattr(dafny_input, "_native_impl"):
+ return dafny_input._native_impl
+
+ else:
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references import (
+ DynamoDbKeyBranchKeyIdSupplier,
+ )
+
+ return DynamoDbKeyBranchKeyIdSupplier(_impl=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.CreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ ddb_key_branch_key_id_supplier=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbKeyBranchKeyIdSupplierReference(
+ dafny_input.ddbKeyBranchKeyIdSupplier
+ )
+ )
+ if (dafny_input.ddbKeyBranchKeyIdSupplier is not None)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionUnion(
+ dafny_input,
+):
+ # Convert GetEncryptedDataKeyDescriptionUnion
+ if isinstance(dafny_input, GetEncryptedDataKeyDescriptionUnion_header):
+ GetEncryptedDataKeyDescriptionUnion_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionUnionHeader(
+ bytes(dafny_input.header)
+ )
+ elif isinstance(dafny_input, GetEncryptedDataKeyDescriptionUnion_item):
+ GetEncryptedDataKeyDescriptionUnion_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionUnionItem(
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.item.items
+ }
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return GetEncryptedDataKeyDescriptionUnion_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionInput(
+ input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionUnion(
+ dafny_input.input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ branch_key_id_supplier=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_BranchKeyIdSupplierReference(
+ dafny_input.branchKeyIdSupplier
+ )
+ )
+ if (dafny_input.branchKeyIdSupplier is not None)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_EncryptedDataKeyDescription(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.EncryptedDataKeyDescription(
+ key_provider_id=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.keyProviderId).decode("utf-16-be"),
+ key_provider_info=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.keyProviderInfo.value).decode("utf-16-be"))
+ if (dafny_input.keyProviderInfo.is_Some)
+ else None
+ ),
+ branch_key_id=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.branchKeyId.value).decode("utf-16-be"))
+ if (dafny_input.branchKeyId.is_Some)
+ else None
+ ),
+ branch_key_version=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.branchKeyVersion.value).decode("utf-16-be"))
+ if (dafny_input.branchKeyVersion.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionOutput(
+ encrypted_data_key_description_output=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedDataKeyDescription(
+ list_element
+ )
+ for list_element in dafny_input.EncryptedDataKeyDescriptionOutput
+ ],
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_AsSet(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.AsSet()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_AtomicPrimitivesReference(dafny_input):
+ from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.client import (
+ AwsCryptographicPrimitives,
+ )
+
+ return AwsCryptographicPrimitives(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_MultiKeyStore(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.MultiKeyStore(
+ key_field_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.keyFieldName).decode("utf-16-be"),
+ cache_ttl=dafny_input.cacheTTL,
+ cache=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CacheType(
+ dafny_input.cache.value
+ )
+ )
+ if (dafny_input.cache.is_Some)
+ else None
+ ),
+ partition_id=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.partitionId.value).decode("utf-16-be"))
+ if (dafny_input.partitionId.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SingleKeyStore(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.SingleKeyStore(
+ key_id=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.keyId).decode("utf-16-be"),
+ cache_ttl=dafny_input.cacheTTL,
+ cache=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CacheType(
+ dafny_input.cache.value
+ )
+ )
+ if (dafny_input.cache.is_Some)
+ else None
+ ),
+ partition_id=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.partitionId.value).decode("utf-16-be"))
+ if (dafny_input.partitionId.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconKeySource(dafny_input):
+ # Convert BeaconKeySource
+ if isinstance(dafny_input, BeaconKeySource_single):
+ BeaconKeySource_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconKeySourceSingle(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_SingleKeyStore(
+ dafny_input.single
+ )
+ )
+ elif isinstance(dafny_input, BeaconKeySource_multi):
+ BeaconKeySource_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconKeySourceMulti(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_MultiKeyStore(
+ dafny_input.multi
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return BeaconKeySource_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_PartOnly(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.PartOnly()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Shared(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.Shared(
+ other=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.other).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SharedSet(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.SharedSet(
+ other=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.other).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconStyle(dafny_input):
+ # Convert BeaconStyle
+ if isinstance(dafny_input, BeaconStyle_partOnly):
+ BeaconStyle_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStylePartOnly(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_PartOnly(
+ dafny_input.partOnly
+ )
+ )
+ elif isinstance(dafny_input, BeaconStyle_shared):
+ BeaconStyle_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleShared(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_Shared(
+ dafny_input.shared
+ )
+ )
+ elif isinstance(dafny_input, BeaconStyle_asSet):
+ BeaconStyle_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleAsSet(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_AsSet(
+ dafny_input.asSet
+ )
+ )
+ elif isinstance(dafny_input, BeaconStyle_sharedSet):
+ BeaconStyle_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleSharedSet(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_SharedSet(
+ dafny_input.sharedSet
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return BeaconStyle_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_ConstructorPart(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.ConstructorPart(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ required=dafny_input.required,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Constructor(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.Constructor(
+ parts=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_ConstructorPart(
+ list_element
+ )
+ for list_element in dafny_input.parts
+ ],
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.EncryptedPart(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ prefix=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.prefix).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.SignedPart(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ prefix=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.prefix).decode("utf-16-be"),
+ loc=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.loc.value).decode("utf-16-be"))
+ if (dafny_input.loc.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CompoundBeacon(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.CompoundBeacon(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ split=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.split).decode("utf-16-be"),
+ encrypted=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(
+ list_element
+ )
+ for list_element in dafny_input.encrypted.value
+ ]
+ )
+ if (dafny_input.encrypted.is_Some)
+ else None
+ ),
+ signed=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(
+ list_element
+ )
+ for list_element in dafny_input.signed.value
+ ]
+ )
+ if (dafny_input.signed.is_Some)
+ else None
+ ),
+ constructors=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_Constructor(
+ list_element
+ )
+ for list_element in dafny_input.constructors.value
+ ]
+ )
+ if (dafny_input.constructors.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_KeyStoreReference(dafny_input):
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.client import (
+ KeyStore,
+ )
+
+ return KeyStore(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_StandardBeacon(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.StandardBeacon(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ length=dafny_input.length,
+ loc=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.loc.value).decode("utf-16-be"))
+ if (dafny_input.loc.is_Some)
+ else None
+ ),
+ style=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_BeaconStyle(
+ dafny_input.style.value
+ )
+ )
+ if (dafny_input.style.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Insert(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.Insert(
+ literal=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.literal).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Lower(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.Lower()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetPrefix(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetPrefix(
+ length=dafny_input.length,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSegment(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetSegment(
+ split=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.split).decode("utf-16-be"),
+ index=dafny_input.index,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSegments(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetSegments(
+ split=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.split).decode("utf-16-be"),
+ low=dafny_input.low,
+ high=dafny_input.high,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSubstring(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetSubstring(
+ low=dafny_input.low,
+ high=dafny_input.high,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSuffix(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetSuffix(
+ length=dafny_input.length,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Upper(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.Upper()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualTransform(dafny_input):
+ # Convert VirtualTransform
+ if isinstance(dafny_input, VirtualTransform_upper):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformUpper(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_Upper(
+ dafny_input.upper
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_lower):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformLower(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_Lower(
+ dafny_input.lower
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_insert):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformInsert(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_Insert(
+ dafny_input.insert
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_prefix):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformPrefix(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetPrefix(
+ dafny_input.prefix
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_suffix):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSuffix(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetSuffix(
+ dafny_input.suffix
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_substring):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSubstring(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetSubstring(
+ dafny_input.substring
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_segment):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSegment(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetSegment(
+ dafny_input.segment
+ )
+ )
+ elif isinstance(dafny_input, VirtualTransform_segments):
+ VirtualTransform_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSegments(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetSegments(
+ dafny_input.segments
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return VirtualTransform_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualPart(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualPart(
+ loc=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.loc).decode("utf-16-be"),
+ trans=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_VirtualTransform(
+ list_element
+ )
+ for list_element in dafny_input.trans.value
+ ]
+ )
+ if (dafny_input.trans.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualField(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualField(
+ name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.name).decode("utf-16-be"),
+ parts=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_VirtualPart(
+ list_element
+ )
+ for list_element in dafny_input.parts
+ ],
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconVersion(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconVersion(
+ version=dafny_input.version,
+ key_store=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_KeyStoreReference(
+ dafny_input.keyStore
+ )
+ )
+ if (dafny_input.keyStore is not None)
+ else None
+ ),
+ key_source=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_BeaconKeySource(
+ dafny_input.keySource
+ ),
+ standard_beacons=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_StandardBeacon(
+ list_element
+ )
+ for list_element in dafny_input.standardBeacons
+ ],
+ compound_beacons=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_CompoundBeacon(
+ list_element
+ )
+ for list_element in dafny_input.compoundBeacons.value
+ ]
+ )
+ if (dafny_input.compoundBeacons.is_Some)
+ else None
+ ),
+ virtual_fields=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_VirtualField(
+ list_element
+ )
+ for list_element in dafny_input.virtualFields.value
+ ]
+ )
+ if (dafny_input.virtualFields.is_Some)
+ else None
+ ),
+ encrypted_parts=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(
+ list_element
+ )
+ for list_element in dafny_input.encryptedParts.value
+ ]
+ )
+ if (dafny_input.encryptedParts.is_Some)
+ else None
+ ),
+ signed_parts=(
+ (
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(
+ list_element
+ )
+ for list_element in dafny_input.signedParts.value
+ ]
+ )
+ if (dafny_input.signedParts.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbEncryptionConfig(dafny_input):
+ # Deferred import of .config to avoid circular dependency
+ import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.config
+
+ return (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.config.DynamoDbEncryptionConfig()
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyDynamoDbEncryptorReference(
+ dafny_input,
+):
+ if hasattr(dafny_input, "_native_impl"):
+ return dafny_input._native_impl
+
+ else:
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references import (
+ LegacyDynamoDbEncryptor,
+ )
+
+ return LegacyDynamoDbEncryptor(_impl=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyPolicy(dafny_input):
+ if isinstance(dafny_input, LegacyPolicy_FORCE__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT):
+ return "FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT"
+
+ elif isinstance(dafny_input, LegacyPolicy_FORBID__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT):
+ return "FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT"
+
+ elif isinstance(dafny_input, LegacyPolicy_FORBID__LEGACY__ENCRYPT__FORBID__LEGACY__DECRYPT):
+ return "FORBID_LEGACY_ENCRYPT_FORBID_LEGACY_DECRYPT"
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {dafny_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.LegacyOverride(
+ policy=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_LegacyPolicy(
+ dafny_input.policy
+ ),
+ encryptor=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_LegacyDynamoDbEncryptorReference(
+ dafny_input.encryptor
+ )
+ )
+ if (dafny_input.encryptor is not None)
+ else None
+ ),
+ attribute_actions_on_encrypt={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.attributeActionsOnEncrypt.items
+ },
+ default_attribute_flag=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ dafny_input.defaultAttributeFlag.value
+ )
+ )
+ if (dafny_input.defaultAttributeFlag.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(dafny_input):
+ if isinstance(dafny_input, PlaintextOverride_FORCE__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ):
+ return "FORCE_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ"
+
+ elif isinstance(dafny_input, PlaintextOverride_FORBID__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ):
+ return "FORBID_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ"
+
+ elif isinstance(dafny_input, PlaintextOverride_FORBID__PLAINTEXT__WRITE__FORBID__PLAINTEXT__READ):
+ return "FORBID_PLAINTEXT_WRITE_FORBID_PLAINTEXT_READ"
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {dafny_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SearchConfig(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.SearchConfig(
+ versions=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_BeaconVersion(
+ list_element
+ )
+ for list_element in dafny_input.versions
+ ],
+ write_version=dafny_input.writeVersion,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTableEncryptionConfig(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.DynamoDbTableEncryptionConfig(
+ logical_table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.logicalTableName).decode(
+ "utf-16-be"
+ ),
+ partition_key_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.partitionKeyName).decode(
+ "utf-16-be"
+ ),
+ sort_key_name=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.sortKeyName.value).decode("utf-16-be"))
+ if (dafny_input.sortKeyName.is_Some)
+ else None
+ ),
+ search=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_SearchConfig(
+ dafny_input.search.value
+ )
+ )
+ if (dafny_input.search.is_Some)
+ else None
+ ),
+ attribute_actions_on_encrypt={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.attributeActionsOnEncrypt.items
+ },
+ allowed_unsigned_attributes=(
+ (
+ [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.allowedUnsignedAttributes.value
+ ]
+ )
+ if (dafny_input.allowedUnsignedAttributes.is_Some)
+ else None
+ ),
+ allowed_unsigned_attribute_prefix=(
+ (
+ b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.allowedUnsignedAttributePrefix.value).decode(
+ "utf-16-be"
+ )
+ )
+ if (dafny_input.allowedUnsignedAttributePrefix.is_Some)
+ else None
+ ),
+ algorithm_suite_id=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId.value
+ )
+ )
+ if (dafny_input.algorithmSuiteId.is_Some)
+ else None
+ ),
+ keyring=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_KeyringReference(
+ dafny_input.keyring.UnwrapOr(None)
+ )
+ )
+ if (dafny_input.keyring.UnwrapOr(None) is not None)
+ else None
+ ),
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm.UnwrapOr(None)
+ )
+ )
+ if (dafny_input.cmm.UnwrapOr(None) is not None)
+ else None
+ ),
+ legacy_override=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(
+ dafny_input.legacyOverride.value
+ )
+ )
+ if (dafny_input.legacyOverride.is_Some)
+ else None
+ ),
+ plaintext_override=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(
+ dafny_input.plaintextOverride.value
+ )
+ )
+ if (dafny_input.plaintextOverride.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTablesEncryptionConfig(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.DynamoDbTablesEncryptionConfig(
+ table_encryption_configs={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTableEncryptionConfig(
+ value
+ )
+ for (key, value) in dafny_input.tableEncryptionConfigs.items
+ },
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/deserialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/deserialize.py
new file mode 100644
index 000000000..425850b07
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/deserialize.py
@@ -0,0 +1,96 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ CreateDynamoDbEncryptionBranchKeyIdSupplierOutput_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierOutput,
+ Error,
+ Error_DynamoDbEncryptionException,
+ GetEncryptedDataKeyDescriptionOutput_GetEncryptedDataKeyDescriptionOutput as DafnyGetEncryptedDataKeyDescriptionOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+from typing import Any
+
+from .dafny_protocol import DafnyResponse
+from .errors import (
+ AwsCryptographicMaterialProviders,
+ AwsCryptographicPrimitives,
+ CollectionOfErrors,
+ ComAmazonawsDynamodb,
+ DynamoDbEncryptionException,
+ KeyStore,
+ OpaqueError,
+ ServiceError,
+ StructuredEncryption,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.deserialize import (
+ _deserialize_error as aws_cryptography_keystore_deserialize_error,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.deserialize import (
+ _deserialize_error as aws_cryptography_materialproviders_deserialize_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.deserialize import (
+ _deserialize_error as aws_cryptography_primitives_deserialize_error,
+)
+
+from ..aws_cryptography_dbencryptionsdk_structuredencryption.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error,
+)
+from .config import Config
+
+
+def _deserialize_create_dynamo_db_encryption_branch_key_id_supplier(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ input.value
+ )
+
+
+def _deserialize_get_encrypted_data_key_description(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionOutput(
+ input.value
+ )
+
+
+def _deserialize_error(error: Error) -> ServiceError:
+ if error.is_Opaque:
+ return OpaqueError(obj=error.obj)
+ elif error.is_OpaqueWithText:
+ return OpaqueErrorWithText(obj=error.obj, obj_message=error.objMessage)
+ elif error.is_CollectionOfErrors:
+ return CollectionOfErrors(
+ message=_dafny.string_of(error.message),
+ list=[_deserialize_error(dafny_e) for dafny_e in error.list],
+ )
+ elif error.is_DynamoDbEncryptionException:
+ return DynamoDbEncryptionException(message=_dafny.string_of(error.message))
+ elif error.is_AwsCryptographyDbEncryptionSdkStructuredEncryption:
+ return StructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error(
+ error.AwsCryptographyDbEncryptionSdkStructuredEncryption
+ )
+ )
+ elif error.is_AwsCryptographyPrimitives:
+ return AwsCryptographicPrimitives(
+ aws_cryptography_primitives_deserialize_error(error.AwsCryptographyPrimitives)
+ )
+ elif error.is_AwsCryptographyMaterialProviders:
+ return AwsCryptographicMaterialProviders(
+ aws_cryptography_materialproviders_deserialize_error(error.AwsCryptographyMaterialProviders)
+ )
+ elif error.is_AwsCryptographyKeyStore:
+ return KeyStore(aws_cryptography_keystore_deserialize_error(error.AwsCryptographyKeyStore))
+ elif error.is_ComAmazonawsDynamodb:
+ return ComAmazonawsDynamodb(message=_dafny.string_of(error.ComAmazonawsDynamodb.message))
+ else:
+ return OpaqueError(obj=error)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/errors.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/errors.py
new file mode 100644
index 000000000..a749fd5e5
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/errors.py
@@ -0,0 +1,335 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_keystore_smithy_error_to_dafny_error,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_materialproviders_smithy_error_to_dafny_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_primitives_smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error,
+)
+from typing import Any, Dict, Generic, List, Literal, TypeVar
+
+
+class ServiceError(Exception):
+ """Base error for all errors in the service."""
+
+ pass
+
+
+T = TypeVar("T")
+
+
+class ApiError(ServiceError, Generic[T]):
+ """Base error for all api errors in the service."""
+
+ code: T
+
+ def __init__(self, message: str):
+ super().__init__(message)
+ self.message = message
+
+
+class UnknownApiError(ApiError[Literal["Unknown"]]):
+ """Error representing any unknown api errors."""
+
+ code: Literal["Unknown"] = "Unknown"
+
+
+class DynamoDbEncryptionException(ApiError[Literal["DynamoDbEncryptionException"]]):
+ code: Literal["DynamoDbEncryptionException"] = "DynamoDbEncryptionException"
+ message: str
+
+ def __init__(
+ self,
+ *,
+ message: str,
+ ):
+ super().__init__(message)
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbEncryptionException to a dictionary."""
+ return {
+ "message": self.message,
+ "code": self.code,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbEncryptionException":
+ """Creates a DynamoDbEncryptionException from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ }
+
+ return DynamoDbEncryptionException(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbEncryptionException("
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbEncryptionException):
+ return False
+ attributes: list[str] = [
+ "message",
+ "message",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DynamoDbEncryptionException(ApiError[Literal["DynamoDbEncryptionException"]]):
+ code: Literal["DynamoDbEncryptionException"] = "DynamoDbEncryptionException"
+ message: str
+
+
+class AwsCryptographicPrimitives(ApiError[Literal["AwsCryptographicPrimitives"]]):
+ AwsCryptographicPrimitives: Any
+
+
+class ComAmazonawsDynamodb(ApiError[Literal["ComAmazonawsDynamodb"]]):
+ ComAmazonawsDynamodb: Any
+
+
+class AwsCryptographicMaterialProviders(ApiError[Literal["AwsCryptographicMaterialProviders"]]):
+ AwsCryptographicMaterialProviders: Any
+
+
+class StructuredEncryption(ApiError[Literal["StructuredEncryption"]]):
+ StructuredEncryption: Any
+
+
+class KeyStore(ApiError[Literal["KeyStore"]]):
+ KeyStore: Any
+
+
+class CollectionOfErrors(ApiError[Literal["CollectionOfErrors"]]):
+ code: Literal["CollectionOfErrors"] = "CollectionOfErrors"
+ message: str
+ list: List[ServiceError]
+
+ def __init__(self, *, message: str, list):
+ super().__init__(message)
+ self.list = list
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CollectionOfErrors to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "list": self.list,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CollectionOfErrors":
+ """Creates a CollectionOfErrors from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "list": d["list"]}
+
+ return CollectionOfErrors(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CollectionOfErrors("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"list={self.list}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CollectionOfErrors):
+ return False
+ if not (self.list == other.list):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueError(ApiError[Literal["OpaqueError"]]):
+ code: Literal["OpaqueError"] = "OpaqueError"
+ obj: Any # As an OpaqueError, type of obj is unknown
+
+ def __init__(self, *, obj):
+ super().__init__("")
+ self.obj = obj
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueError":
+ """Creates a OpaqueError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "obj": d["obj"]}
+
+ return OpaqueError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueWithTextError(ApiError[Literal["OpaqueWithTextError"]]):
+ code: Literal["OpaqueWithTextError"] = "OpaqueWithTextError"
+ obj: Any # As an OpaqueWithTextError, type of obj is unknown
+ obj_message: str # obj_message is a message representing the details of obj
+
+ def __init__(self, *, obj, obj_message):
+ super().__init__("")
+ self.obj = obj
+ self.obj_message = obj_message
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueWithTextError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ "obj_message": self.obj_message,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueWithTextError":
+ """Creates a OpaqueWithTextError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ "obj": d["obj"],
+ "obj_message": d["obj_message"],
+ }
+
+ return OpaqueWithTextError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueWithTextError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += f"obj_message={self.obj_message}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueWithTextError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _smithy_error_to_dafny_error(e: ServiceError):
+ """Converts the provided native Smithy-modeled error into the corresponding
+ Dafny error."""
+ if isinstance(
+ e,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors.DynamoDbEncryptionException,
+ ):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_DynamoDbEncryptionException(
+ message=_dafny.Seq(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicPrimitives):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_AwsCryptographyPrimitives(
+ aws_cryptography_primitives_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, ComAmazonawsDynamodb):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_ComAmazonawsDynamodb(
+ com_amazonaws_dynamodb_sdk_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicMaterialProviders):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_AwsCryptographyMaterialProviders(
+ aws_cryptography_materialproviders_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, StructuredEncryption):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_AwsCryptographyDbEncryptionSdkStructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, KeyStore):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_AwsCryptographyKeyStore(
+ aws_cryptography_keystore_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, CollectionOfErrors):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_CollectionOfErrors(
+ message=_dafny.Seq(e.message),
+ list=_dafny.Seq(_smithy_error_to_dafny_error(native_err) for native_err in e.list),
+ )
+
+ if isinstance(e, OpaqueError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_Opaque(
+ obj=e.obj
+ )
+
+ if isinstance(e, OpaqueWithTextError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_OpaqueWithText(
+ obj=e.obj, objMessage=e.obj_message
+ )
+
+ else:
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.Error_Opaque(
+ obj=e
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/models.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/models.py
new file mode 100644
index 000000000..1bf09dab2
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/models.py
@@ -0,0 +1,2999 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.client
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references
+from typing import Any, Dict, List, Optional, Union
+
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.models import (
+ CacheType,
+ _cache_type_from_dict,
+)
+
+
+class CreateDynamoDbEncryptionBranchKeyIdSupplierInput:
+ ddb_key_branch_key_id_supplier: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references.DynamoDbKeyBranchKeyIdSupplier"
+
+ def __init__(
+ self,
+ *,
+ ddb_key_branch_key_id_supplier: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references.DynamoDbKeyBranchKeyIdSupplier",
+ ):
+ """Inputs for creating a Branch Key Supplier from a DynamoDB Key Branch
+ Key Id Supplier.
+
+ :param ddb_key_branch_key_id_supplier: An implementation of the
+ DynamoDbKeyBranchKeyIdSupplier interface, which determines
+ what Branch Key to use for data key wrapping/unwrapping
+ based on the DynamoDB item being written/read.
+ """
+ self.ddb_key_branch_key_id_supplier = ddb_key_branch_key_id_supplier
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CreateDynamoDbEncryptionBranchKeyIdSupplierInput to a
+ dictionary."""
+ return {
+ "ddb_key_branch_key_id_supplier": self.ddb_key_branch_key_id_supplier.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(
+ d: Dict[str, Any],
+ ) -> "CreateDynamoDbEncryptionBranchKeyIdSupplierInput":
+ """Creates a CreateDynamoDbEncryptionBranchKeyIdSupplierInput from a
+ dictionary."""
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references import (
+ DynamoDbKeyBranchKeyIdSupplier,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "ddb_key_branch_key_id_supplier": DynamoDbKeyBranchKeyIdSupplier.from_dict(
+ d["ddb_key_branch_key_id_supplier"]
+ ),
+ }
+
+ return CreateDynamoDbEncryptionBranchKeyIdSupplierInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CreateDynamoDbEncryptionBranchKeyIdSupplierInput("
+ if self.ddb_key_branch_key_id_supplier is not None:
+ result += f"ddb_key_branch_key_id_supplier={repr(self.ddb_key_branch_key_id_supplier)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CreateDynamoDbEncryptionBranchKeyIdSupplierInput):
+ return False
+ attributes: list[str] = [
+ "ddb_key_branch_key_id_supplier",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class CreateDynamoDbEncryptionBranchKeyIdSupplierOutput:
+ branch_key_id_supplier: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.BranchKeyIdSupplier"
+
+ def __init__(
+ self,
+ *,
+ branch_key_id_supplier: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.BranchKeyIdSupplier",
+ ):
+ """Outputs for creating a Branch Key Supplier from a DynamoDB Key
+ Branch Key Id Supplier.
+
+ :param branch_key_id_supplier: The Branch Key Supplier for use
+ with the Hierarchical Keyring.
+ """
+ self.branch_key_id_supplier = branch_key_id_supplier
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CreateDynamoDbEncryptionBranchKeyIdSupplierOutput to a
+ dictionary."""
+ return {
+ "branch_key_id_supplier": self.branch_key_id_supplier.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(
+ d: Dict[str, Any],
+ ) -> "CreateDynamoDbEncryptionBranchKeyIdSupplierOutput":
+ """Creates a CreateDynamoDbEncryptionBranchKeyIdSupplierOutput from a
+ dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ BranchKeyIdSupplier,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "branch_key_id_supplier": BranchKeyIdSupplier.from_dict(d["branch_key_id_supplier"]),
+ }
+
+ return CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CreateDynamoDbEncryptionBranchKeyIdSupplierOutput("
+ if self.branch_key_id_supplier is not None:
+ result += f"branch_key_id_supplier={repr(self.branch_key_id_supplier)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CreateDynamoDbEncryptionBranchKeyIdSupplierOutput):
+ return False
+ attributes: list[str] = [
+ "branch_key_id_supplier",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetBranchKeyIdFromDdbKeyOutput:
+ branch_key_id: str
+
+ def __init__(
+ self,
+ *,
+ branch_key_id: str,
+ ):
+ """Outputs for getting the Branch Key that should be used for wrapping
+ and unwrapping data keys.
+
+ :param branch_key_id: The ID of the Branch Key that should be
+ used to wrap and unwrap data keys for this item.
+ """
+ self.branch_key_id = branch_key_id
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetBranchKeyIdFromDdbKeyOutput to a dictionary."""
+ return {
+ "branch_key_id": self.branch_key_id,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetBranchKeyIdFromDdbKeyOutput":
+ """Creates a GetBranchKeyIdFromDdbKeyOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "branch_key_id": d["branch_key_id"],
+ }
+
+ return GetBranchKeyIdFromDdbKeyOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetBranchKeyIdFromDdbKeyOutput("
+ if self.branch_key_id is not None:
+ result += f"branch_key_id={repr(self.branch_key_id)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetBranchKeyIdFromDdbKeyOutput):
+ return False
+ attributes: list[str] = [
+ "branch_key_id",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptedDataKeyDescription:
+ key_provider_id: str
+ key_provider_info: Optional[str]
+ branch_key_id: Optional[str]
+ branch_key_version: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ key_provider_id: str,
+ key_provider_info: Optional[str] = None,
+ branch_key_id: Optional[str] = None,
+ branch_key_version: Optional[str] = None,
+ ):
+ """
+ :param key_provider_id: Key provider id of the encrypted data key.
+ :param key_provider_info: Key provider information of the encrypted data key.
+ :param branch_key_id: Branch key id of the encrypted data key.
+ :param branch_key_version: Branch key version of the encrypted data key.
+ """
+ self.key_provider_id = key_provider_id
+ self.key_provider_info = key_provider_info
+ self.branch_key_id = branch_key_id
+ self.branch_key_version = branch_key_version
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptedDataKeyDescription to a dictionary."""
+ d: Dict[str, Any] = {
+ "key_provider_id": self.key_provider_id,
+ }
+
+ if self.key_provider_info is not None:
+ d["key_provider_info"] = self.key_provider_info
+
+ if self.branch_key_id is not None:
+ d["branch_key_id"] = self.branch_key_id
+
+ if self.branch_key_version is not None:
+ d["branch_key_version"] = self.branch_key_version
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptedDataKeyDescription":
+ """Creates a EncryptedDataKeyDescription from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key_provider_id": d["key_provider_id"],
+ }
+
+ if "key_provider_info" in d:
+ kwargs["key_provider_info"] = d["key_provider_info"]
+
+ if "branch_key_id" in d:
+ kwargs["branch_key_id"] = d["branch_key_id"]
+
+ if "branch_key_version" in d:
+ kwargs["branch_key_version"] = d["branch_key_version"]
+
+ return EncryptedDataKeyDescription(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptedDataKeyDescription("
+ if self.key_provider_id is not None:
+ result += f"key_provider_id={repr(self.key_provider_id)}, "
+
+ if self.key_provider_info is not None:
+ result += f"key_provider_info={repr(self.key_provider_info)}, "
+
+ if self.branch_key_id is not None:
+ result += f"branch_key_id={repr(self.branch_key_id)}, "
+
+ if self.branch_key_version is not None:
+ result += f"branch_key_version={repr(self.branch_key_version)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptedDataKeyDescription):
+ return False
+ attributes: list[str] = [
+ "key_provider_id",
+ "key_provider_info",
+ "branch_key_id",
+ "branch_key_version",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetEncryptedDataKeyDescriptionOutput:
+ encrypted_data_key_description_output: list[EncryptedDataKeyDescription]
+
+ def __init__(
+ self,
+ *,
+ encrypted_data_key_description_output: list[EncryptedDataKeyDescription],
+ ):
+ """Output for getting encrypted data key description.
+
+ :param encrypted_data_key_description_output: A list of
+ encrypted data key description.
+ """
+ self.encrypted_data_key_description_output = encrypted_data_key_description_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetEncryptedDataKeyDescriptionOutput to a
+ dictionary."""
+ return {
+ "encrypted_data_key_description_output": _encrypted_data_key_description_list_as_dict(
+ self.encrypted_data_key_description_output
+ ),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetEncryptedDataKeyDescriptionOutput":
+ """Creates a GetEncryptedDataKeyDescriptionOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "encrypted_data_key_description_output": _encrypted_data_key_description_list_from_dict(
+ d["encrypted_data_key_description_output"]
+ ),
+ }
+
+ return GetEncryptedDataKeyDescriptionOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetEncryptedDataKeyDescriptionOutput("
+ if self.encrypted_data_key_description_output is not None:
+ result += f"encrypted_data_key_description_output={repr(self.encrypted_data_key_description_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetEncryptedDataKeyDescriptionOutput):
+ return False
+ attributes: list[str] = [
+ "encrypted_data_key_description_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetBranchKeyIdFromDdbKeyInput:
+ ddb_key: "dict[str, dict[str, Any]]"
+
+ def __init__(
+ self,
+ *,
+ ddb_key: "dict[str, dict[str, Any]]",
+ ):
+ """Inputs for getting the Branch Key that should be used for wrapping
+ and unwrapping data keys.
+
+ :param ddb_key: The partition and sort (if it exists) attributes
+ on the item being read or written, along with the values of
+ any attributes configured as
+ SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT.
+ """
+ self.ddb_key = ddb_key
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetBranchKeyIdFromDdbKeyInput to a dictionary."""
+ return {
+ "ddb_key": self.ddb_key,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetBranchKeyIdFromDdbKeyInput":
+ """Creates a GetBranchKeyIdFromDdbKeyInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "ddb_key": d["ddb_key"],
+ }
+
+ return GetBranchKeyIdFromDdbKeyInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetBranchKeyIdFromDdbKeyInput("
+ if self.ddb_key is not None:
+ result += f"ddb_key={repr(self.ddb_key)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetBranchKeyIdFromDdbKeyInput):
+ return False
+ attributes: list[str] = [
+ "ddb_key",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetEncryptedDataKeyDescriptionUnionHeader:
+ """A binary header value."""
+
+ def __init__(self, value: bytes | bytearray):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"header": self.value}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetEncryptedDataKeyDescriptionUnionHeader":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return GetEncryptedDataKeyDescriptionUnionHeader(d["header"])
+
+ def __repr__(self) -> str:
+ return f"GetEncryptedDataKeyDescriptionUnionHeader(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetEncryptedDataKeyDescriptionUnionHeader):
+ return False
+ return self.value == other.value
+
+
+class GetEncryptedDataKeyDescriptionUnionItem:
+ """A DynamoDB item."""
+
+ def __init__(self, value: "dict[str, dict[str, Any]]"):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"item": self.value}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetEncryptedDataKeyDescriptionUnionItem":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return GetEncryptedDataKeyDescriptionUnionItem(d["item"])
+
+ def __repr__(self) -> str:
+ return f"GetEncryptedDataKeyDescriptionUnionItem(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetEncryptedDataKeyDescriptionUnionItem):
+ return False
+ return self.value == other.value
+
+
+class GetEncryptedDataKeyDescriptionUnionUnknown:
+ """Represents an unknown variant.
+
+ If you receive this value, you will need to update your library to
+ receive the parsed value.
+
+ This value may not be deliberately sent.
+ """
+
+ def __init__(self, tag: str):
+ self.tag = tag
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"SDK_UNKNOWN_MEMBER": {"name": self.tag}}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetEncryptedDataKeyDescriptionUnionUnknown":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+ return GetEncryptedDataKeyDescriptionUnionUnknown(d["SDK_UNKNOWN_MEMBER"]["name"])
+
+ def __repr__(self) -> str:
+ return f"GetEncryptedDataKeyDescriptionUnionUnknown(tag={self.tag})"
+
+
+GetEncryptedDataKeyDescriptionUnion = Union[
+ GetEncryptedDataKeyDescriptionUnionHeader,
+ GetEncryptedDataKeyDescriptionUnionItem,
+ GetEncryptedDataKeyDescriptionUnionUnknown,
+]
+
+
+def _get_encrypted_data_key_description_union_from_dict(
+ d: Dict[str, Any],
+) -> GetEncryptedDataKeyDescriptionUnion:
+ if "header" in d:
+ return GetEncryptedDataKeyDescriptionUnionHeader.from_dict(d)
+
+ if "item" in d:
+ return GetEncryptedDataKeyDescriptionUnionItem.from_dict(d)
+
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+
+class GetEncryptedDataKeyDescriptionInput:
+ input: "GetEncryptedDataKeyDescriptionUnion"
+
+ def __init__(
+ self,
+ *,
+ input: "GetEncryptedDataKeyDescriptionUnion",
+ ):
+ """Input for getting encrypted data key description."""
+ self.input = input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetEncryptedDataKeyDescriptionInput to a dictionary."""
+ return {
+ "input": self.input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetEncryptedDataKeyDescriptionInput":
+ """Creates a GetEncryptedDataKeyDescriptionInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "input": _get_encrypted_data_key_description_union_from_dict(d["input"]),
+ }
+
+ return GetEncryptedDataKeyDescriptionInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetEncryptedDataKeyDescriptionInput("
+ if self.input is not None:
+ result += f"input={repr(self.input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetEncryptedDataKeyDescriptionInput):
+ return False
+ attributes: list[str] = [
+ "input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class AsSet:
+ """Attribute must be a Set.
+
+ Beacon value will also be a Set.
+ """
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the AsSet to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "AsSet":
+ """Creates a AsSet from a dictionary."""
+ return AsSet()
+
+ def __repr__(self) -> str:
+ result = "AsSet("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, AsSet)
+
+
+class MultiKeyStore:
+ key_field_name: str
+ cache_ttl: int
+ cache: Optional[CacheType]
+ partition_id: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ key_field_name: str,
+ cache_ttl: int,
+ cache: Optional[CacheType] = None,
+ partition_id: Optional[str] = None,
+ ):
+ """The configuration for using multiple Beacon Keys.
+
+ :param key_field_name: The name of the field that stores the
+ Beacon Key. This may be a Virtual Field.
+ :param cache_ttl: How long (in seconds) the beacon key material
+ is cached locally before it is re-retrieved from DynamoDB
+ and re-authed with AWS KMS.
+ :param cache: Which type of local cache to use.
+ :param partition_id: Partition ID to distinguish Beacon Key
+ Sources writing to a Shared cache. If the Partition ID is
+ the same for two Beacon Key Sources, they can share the same
+ cache entries in the Shared cache.
+ """
+ self.key_field_name = key_field_name
+ self.cache_ttl = cache_ttl
+ self.cache = cache
+ self.partition_id = partition_id
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the MultiKeyStore to a dictionary."""
+ d: Dict[str, Any] = {
+ "key_field_name": self.key_field_name,
+ "cache_ttl": self.cache_ttl,
+ }
+
+ if self.cache is not None:
+ d["cache"] = self.cache.as_dict()
+
+ if self.partition_id is not None:
+ d["partition_id"] = self.partition_id
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "MultiKeyStore":
+ """Creates a MultiKeyStore from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key_field_name": d["key_field_name"],
+ "cache_ttl": d["cache_ttl"],
+ }
+
+ if "cache" in d:
+ kwargs["cache"] = (_cache_type_from_dict(d["cache"]),)
+
+ if "partition_id" in d:
+ kwargs["partition_id"] = d["partition_id"]
+
+ return MultiKeyStore(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "MultiKeyStore("
+ if self.key_field_name is not None:
+ result += f"key_field_name={repr(self.key_field_name)}, "
+
+ if self.cache_ttl is not None:
+ result += f"cache_ttl={repr(self.cache_ttl)}, "
+
+ if self.cache is not None:
+ result += f"cache={repr(self.cache)}, "
+
+ if self.partition_id is not None:
+ result += f"partition_id={repr(self.partition_id)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, MultiKeyStore):
+ return False
+ attributes: list[str] = [
+ "key_field_name",
+ "cache_ttl",
+ "cache",
+ "partition_id",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class SingleKeyStore:
+ key_id: str
+ cache_ttl: int
+ cache: Optional[CacheType]
+ partition_id: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ key_id: str,
+ cache_ttl: int,
+ cache: Optional[CacheType] = None,
+ partition_id: Optional[str] = None,
+ ):
+ """The configuration for using a single Beacon Key.
+
+ :param key_id: The Beacon Key ID.
+ :param cache_ttl: How long (in seconds) the beacon key material is cached
+ locally before it is re-retrieved from DynamoDB and re-authed with AWS KMS.
+ :param cache: Which type of local cache to use. Please see the
+ [spec](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/specification/searchable-encryption/search-config.md#key-store-cache)
+ on how to provide a cache for a SingleKeyStore.
+ :param partition_id: Partition ID to distinguish Beacon Key Sources writing to a
+ Shared cache. If the Partition ID is the same for two Beacon Key Sources, they
+ can share the same cache entries in the Shared cache.
+ """
+ self.key_id = key_id
+ self.cache_ttl = cache_ttl
+ self.cache = cache
+ self.partition_id = partition_id
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the SingleKeyStore to a dictionary."""
+ d: Dict[str, Any] = {
+ "key_id": self.key_id,
+ "cache_ttl": self.cache_ttl,
+ }
+
+ if self.cache is not None:
+ d["cache"] = self.cache.as_dict()
+
+ if self.partition_id is not None:
+ d["partition_id"] = self.partition_id
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "SingleKeyStore":
+ """Creates a SingleKeyStore from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key_id": d["key_id"],
+ "cache_ttl": d["cache_ttl"],
+ }
+
+ if "cache" in d:
+ kwargs["cache"] = (_cache_type_from_dict(d["cache"]),)
+
+ if "partition_id" in d:
+ kwargs["partition_id"] = d["partition_id"]
+
+ return SingleKeyStore(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "SingleKeyStore("
+ if self.key_id is not None:
+ result += f"key_id={repr(self.key_id)}, "
+
+ if self.cache_ttl is not None:
+ result += f"cache_ttl={repr(self.cache_ttl)}, "
+
+ if self.cache is not None:
+ result += f"cache={repr(self.cache)}, "
+
+ if self.partition_id is not None:
+ result += f"partition_id={repr(self.partition_id)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, SingleKeyStore):
+ return False
+ attributes: list[str] = [
+ "key_id",
+ "cache_ttl",
+ "cache",
+ "partition_id",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BeaconKeySourceSingle:
+ """The configuration for using a single Beacon Key."""
+
+ def __init__(self, value: SingleKeyStore):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"single": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconKeySourceSingle":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconKeySourceSingle(SingleKeyStore.from_dict(d["single"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconKeySourceSingle(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconKeySourceSingle):
+ return False
+ return self.value == other.value
+
+
+class BeaconKeySourceMulti:
+ """The configuration for using multiple Beacon Keys."""
+
+ def __init__(self, value: MultiKeyStore):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"multi": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconKeySourceMulti":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconKeySourceMulti(MultiKeyStore.from_dict(d["multi"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconKeySourceMulti(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconKeySourceMulti):
+ return False
+ return self.value == other.value
+
+
+class BeaconKeySourceUnknown:
+ """Represents an unknown variant.
+
+ If you receive this value, you will need to update your library to
+ receive the parsed value.
+
+ This value may not be deliberately sent.
+ """
+
+ def __init__(self, tag: str):
+ self.tag = tag
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"SDK_UNKNOWN_MEMBER": {"name": self.tag}}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconKeySourceUnknown":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+ return BeaconKeySourceUnknown(d["SDK_UNKNOWN_MEMBER"]["name"])
+
+ def __repr__(self) -> str:
+ return f"BeaconKeySourceUnknown(tag={self.tag})"
+
+
+BeaconKeySource = Union[BeaconKeySourceSingle, BeaconKeySourceMulti, BeaconKeySourceUnknown]
+
+
+def _beacon_key_source_from_dict(d: Dict[str, Any]) -> BeaconKeySource:
+ if "single" in d:
+ return BeaconKeySourceSingle.from_dict(d)
+
+ if "multi" in d:
+ return BeaconKeySourceMulti.from_dict(d)
+
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+
+class PartOnly:
+ """Attribute must be used as part of a Compound Beacon, never alone."""
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the PartOnly to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PartOnly":
+ """Creates a PartOnly from a dictionary."""
+ return PartOnly()
+
+ def __repr__(self) -> str:
+ result = "PartOnly("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, PartOnly)
+
+
+class Shared:
+ other: str
+
+ def __init__(
+ self,
+ *,
+ other: str,
+ ):
+ """This beacon should calculate values like another beacon, so they can
+ be compared.
+
+ :param other: Calculate beacon values as for this beacon.
+ """
+ self.other = other
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the Shared to a dictionary."""
+ return {
+ "other": self.other,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "Shared":
+ """Creates a Shared from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "other": d["other"],
+ }
+
+ return Shared(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "Shared("
+ if self.other is not None:
+ result += f"other={repr(self.other)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, Shared):
+ return False
+ attributes: list[str] = [
+ "other",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class SharedSet:
+ other: str
+
+ def __init__(
+ self,
+ *,
+ other: str,
+ ):
+ """Both Shared and AsSet.
+
+ :param other: Calculate beacon values as for this beacon.
+ """
+ self.other = other
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the SharedSet to a dictionary."""
+ return {
+ "other": self.other,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "SharedSet":
+ """Creates a SharedSet from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "other": d["other"],
+ }
+
+ return SharedSet(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "SharedSet("
+ if self.other is not None:
+ result += f"other={repr(self.other)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, SharedSet):
+ return False
+ attributes: list[str] = [
+ "other",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BeaconStylePartOnly:
+ """Attribute must be used as part of a Compound Beacon, never alone."""
+
+ def __init__(self, value: PartOnly):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"partOnly": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconStylePartOnly":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconStylePartOnly(PartOnly.from_dict(d["partOnly"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconStylePartOnly(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconStylePartOnly):
+ return False
+ return self.value == other.value
+
+
+class BeaconStyleShared:
+ """This beacon should calculate values like another beacon, so they can be
+ compared."""
+
+ def __init__(self, value: Shared):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"shared": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconStyleShared":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconStyleShared(Shared.from_dict(d["shared"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconStyleShared(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconStyleShared):
+ return False
+ return self.value == other.value
+
+
+class BeaconStyleAsSet:
+ """Attribute must be a Set.
+
+ Beacon value will also be a Set.
+ """
+
+ def __init__(self, value: AsSet):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"asSet": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconStyleAsSet":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconStyleAsSet(AsSet.from_dict(d["asSet"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconStyleAsSet(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconStyleAsSet):
+ return False
+ return self.value == other.value
+
+
+class BeaconStyleSharedSet:
+ """Both Shared and AsSet."""
+
+ def __init__(self, value: SharedSet):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"sharedSet": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconStyleSharedSet":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return BeaconStyleSharedSet(SharedSet.from_dict(d["sharedSet"]))
+
+ def __repr__(self) -> str:
+ return f"BeaconStyleSharedSet(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconStyleSharedSet):
+ return False
+ return self.value == other.value
+
+
+class BeaconStyleUnknown:
+ """Represents an unknown variant.
+
+ If you receive this value, you will need to update your library to
+ receive the parsed value.
+
+ This value may not be deliberately sent.
+ """
+
+ def __init__(self, tag: str):
+ self.tag = tag
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"SDK_UNKNOWN_MEMBER": {"name": self.tag}}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconStyleUnknown":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+ return BeaconStyleUnknown(d["SDK_UNKNOWN_MEMBER"]["name"])
+
+ def __repr__(self) -> str:
+ return f"BeaconStyleUnknown(tag={self.tag})"
+
+
+BeaconStyle = Union[
+ BeaconStylePartOnly,
+ BeaconStyleShared,
+ BeaconStyleAsSet,
+ BeaconStyleSharedSet,
+ BeaconStyleUnknown,
+]
+
+
+def _beacon_style_from_dict(d: Dict[str, Any]) -> BeaconStyle:
+ if "partOnly" in d:
+ return BeaconStylePartOnly.from_dict(d)
+
+ if "shared" in d:
+ return BeaconStyleShared.from_dict(d)
+
+ if "asSet" in d:
+ return BeaconStyleAsSet.from_dict(d)
+
+ if "sharedSet" in d:
+ return BeaconStyleSharedSet.from_dict(d)
+
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+
+class ConstructorPart:
+ name: str
+ required: bool
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ required: bool,
+ ):
+ """A part of a Compound Becaon Construction.
+
+ :param name: The name of the Encrypted Part or Signed Part for
+ which this constructor part gets a value.
+ :param required: Whether this Encrypted Part or Signed Part is
+ required for this construction to succeed.
+ """
+ self.name = name
+ self.required = required
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ConstructorPart to a dictionary."""
+ return {
+ "name": self.name,
+ "required": self.required,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ConstructorPart":
+ """Creates a ConstructorPart from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ "required": d["required"],
+ }
+
+ return ConstructorPart(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ConstructorPart("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.required is not None:
+ result += f"required={repr(self.required)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ConstructorPart):
+ return False
+ attributes: list[str] = [
+ "name",
+ "required",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Constructor:
+ parts: list[ConstructorPart]
+
+ def __init__(
+ self,
+ *,
+ parts: list[ConstructorPart],
+ ):
+ """The configuration for a particular Compound Beacon construction.
+
+ :param parts: The ordered list of parts for a particular
+ Compound Beacon construction. If the item contains all
+ required Parts, a Compound beacon will be written using each
+ Part that exists on the item, in the order specified.
+ """
+ if (parts is not None) and (len(parts) < 1):
+ raise ValueError("The size of parts must be greater than or equal to 1")
+
+ self.parts = parts
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the Constructor to a dictionary."""
+ return {
+ "parts": _constructor_part_list_as_dict(self.parts),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "Constructor":
+ """Creates a Constructor from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "parts": _constructor_part_list_from_dict(d["parts"]),
+ }
+
+ return Constructor(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "Constructor("
+ if self.parts is not None:
+ result += f"parts={repr(self.parts)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, Constructor):
+ return False
+ attributes: list[str] = [
+ "parts",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptedPart:
+ name: str
+ prefix: str
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ prefix: str,
+ ):
+ """A part of a Compound Beacon that contains a beacon over encrypted
+ data.
+
+ :param name: The name of the Standard Beacon, whose value this
+ Part will hold.
+ :param prefix: The prefix that is written with this Encrypted
+ Part.
+ """
+ self.name = name
+ if (prefix is not None) and (len(prefix) < 1):
+ raise ValueError("The size of prefix must be greater than or equal to 1")
+
+ self.prefix = prefix
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptedPart to a dictionary."""
+ return {
+ "name": self.name,
+ "prefix": self.prefix,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptedPart":
+ """Creates a EncryptedPart from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ "prefix": d["prefix"],
+ }
+
+ return EncryptedPart(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptedPart("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.prefix is not None:
+ result += f"prefix={repr(self.prefix)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptedPart):
+ return False
+ attributes: list[str] = [
+ "name",
+ "prefix",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class SignedPart:
+ name: str
+ prefix: str
+ loc: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ prefix: str,
+ loc: Optional[str] = None,
+ ):
+ """A part of a Compound Beacon that contains signed plaintext data.
+
+ :param name: The name for this Signed Part.
+ :param prefix: The prefix that is written with this Signed Part.
+ :param loc: The DynamoDB document path to the value for this
+ Signed Part. If not provided, the 'name' is used for the
+ location.
+ """
+ self.name = name
+ if (prefix is not None) and (len(prefix) < 1):
+ raise ValueError("The size of prefix must be greater than or equal to 1")
+
+ self.prefix = prefix
+ if (loc is not None) and (len(loc) < 1):
+ raise ValueError("The size of loc must be greater than or equal to 1")
+
+ self.loc = loc
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the SignedPart to a dictionary."""
+ d: Dict[str, Any] = {
+ "name": self.name,
+ "prefix": self.prefix,
+ }
+
+ if self.loc is not None:
+ d["loc"] = self.loc
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "SignedPart":
+ """Creates a SignedPart from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ "prefix": d["prefix"],
+ }
+
+ if "loc" in d:
+ kwargs["loc"] = d["loc"]
+
+ return SignedPart(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "SignedPart("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.prefix is not None:
+ result += f"prefix={repr(self.prefix)}, "
+
+ if self.loc is not None:
+ result += f"loc={repr(self.loc)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, SignedPart):
+ return False
+ attributes: list[str] = [
+ "name",
+ "prefix",
+ "loc",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class CompoundBeacon:
+ name: str
+ split: str
+ encrypted: Optional[list[EncryptedPart]]
+ signed: Optional[list[SignedPart]]
+ constructors: Optional[list[Constructor]]
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ split: str,
+ encrypted: Optional[list[EncryptedPart]] = None,
+ signed: Optional[list[SignedPart]] = None,
+ constructors: Optional[list[Constructor]] = None,
+ ):
+ """The configuration for a Compound Beacon.
+
+ :param name: The name of the Compound Beacon.
+ :param split: The characters used to split parts of a compound
+ beacon. The split character should be a character that does
+ not appear in any Signed Part or Prefix used by the Compound
+ Beacon.
+ :param encrypted: The list of Encrypted Parts that may be
+ included in the compound beacon.
+ :param signed: The list of Signed Parts that may be included in
+ the compound beacon.
+ :param constructors: The ordered list of constructors that may
+ be used to create the Compound Beacon. Each constructor is
+ checked, in order, to see if it can construct the beacon.
+ The first constructor that can construct the beacon is used.
+ If no constructor can construct the beacon, the Compound
+ Beacon is not written to the item.
+ """
+ self.name = name
+ if (split is not None) and (len(split) < 1):
+ raise ValueError("The size of split must be greater than or equal to 1")
+
+ if (split is not None) and (len(split) > 1):
+ raise ValueError("The size of split must be less than or equal to 1")
+
+ self.split = split
+ if (encrypted is not None) and (len(encrypted) < 1):
+ raise ValueError("The size of encrypted must be greater than or equal to 1")
+
+ self.encrypted = encrypted
+ if (signed is not None) and (len(signed) < 1):
+ raise ValueError("The size of signed must be greater than or equal to 1")
+
+ self.signed = signed
+ if (constructors is not None) and (len(constructors) < 1):
+ raise ValueError("The size of constructors must be greater than or equal to 1")
+
+ self.constructors = constructors
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CompoundBeacon to a dictionary."""
+ d: Dict[str, Any] = {
+ "name": self.name,
+ "split": self.split,
+ }
+
+ if self.encrypted is not None:
+ d["encrypted"] = (_encrypted_parts_list_as_dict(self.encrypted),)
+
+ if self.signed is not None:
+ d["signed"] = (_signed_parts_list_as_dict(self.signed),)
+
+ if self.constructors is not None:
+ d["constructors"] = (_constructor_list_as_dict(self.constructors),)
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CompoundBeacon":
+ """Creates a CompoundBeacon from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ "split": d["split"],
+ }
+
+ if "encrypted" in d:
+ kwargs["encrypted"] = (_encrypted_parts_list_from_dict(d["encrypted"]),)
+
+ if "signed" in d:
+ kwargs["signed"] = (_signed_parts_list_from_dict(d["signed"]),)
+
+ if "constructors" in d:
+ kwargs["constructors"] = (_constructor_list_from_dict(d["constructors"]),)
+
+ return CompoundBeacon(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CompoundBeacon("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.split is not None:
+ result += f"split={repr(self.split)}, "
+
+ if self.encrypted is not None:
+ result += f"encrypted={repr(self.encrypted)}, "
+
+ if self.signed is not None:
+ result += f"signed={repr(self.signed)}, "
+
+ if self.constructors is not None:
+ result += f"constructors={repr(self.constructors)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CompoundBeacon):
+ return False
+ attributes: list[str] = [
+ "name",
+ "split",
+ "encrypted",
+ "signed",
+ "constructors",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class StandardBeacon:
+ name: str
+ length: int
+ loc: Optional[str]
+ style: Optional[BeaconStyle]
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ length: int = 0,
+ loc: Optional[str] = None,
+ style: Optional[BeaconStyle] = None,
+ ):
+ """The configuration for a Standard Beacon.
+
+ :param name: The name for this Standard Beacon.
+ :param length: The length of the calculated beacon.
+ :param loc: The DynamoDB document path to the value this beacon
+ will calculate over. If not specified, the beacon will
+ calculate values for the attribute with the name specified
+ in 'name'.
+ :param style: Optional augmented behavior.
+ """
+ self.name = name
+ if (length is not None) and (length < 1):
+ raise ValueError("length must be greater than or equal to 1")
+
+ if (length is not None) and (length > 63):
+ raise ValueError("length must be less than or equal to 63")
+
+ self.length = length
+ if (loc is not None) and (len(loc) < 1):
+ raise ValueError("The size of loc must be greater than or equal to 1")
+
+ self.loc = loc
+ self.style = style
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the StandardBeacon to a dictionary."""
+ d: Dict[str, Any] = {
+ "name": self.name,
+ }
+
+ if self.length is not None:
+ d["length"] = self.length
+
+ if self.loc is not None:
+ d["loc"] = self.loc
+
+ if self.style is not None:
+ d["style"] = self.style.as_dict()
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "StandardBeacon":
+ """Creates a StandardBeacon from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ }
+
+ if "length" in d:
+ kwargs["length"] = d["length"]
+
+ if "loc" in d:
+ kwargs["loc"] = d["loc"]
+
+ if "style" in d:
+ kwargs["style"] = (_beacon_style_from_dict(d["style"]),)
+
+ return StandardBeacon(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "StandardBeacon("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.length is not None:
+ result += f"length={repr(self.length)}, "
+
+ if self.loc is not None:
+ result += f"loc={repr(self.loc)}, "
+
+ if self.style is not None:
+ result += f"style={repr(self.style)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, StandardBeacon):
+ return False
+ attributes: list[str] = [
+ "name",
+ "length",
+ "loc",
+ "style",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Insert:
+ literal: str
+
+ def __init__(
+ self,
+ *,
+ literal: str,
+ ):
+ """The Virtual Part Transformation that appends a literal string.
+
+ :param literal: The literal string to append.
+ """
+ self.literal = literal
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the Insert to a dictionary."""
+ return {
+ "literal": self.literal,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "Insert":
+ """Creates a Insert from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "literal": d["literal"],
+ }
+
+ return Insert(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "Insert("
+ if self.literal is not None:
+ result += f"literal={repr(self.literal)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, Insert):
+ return False
+ attributes: list[str] = [
+ "literal",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Lower:
+ """The Virtual Part Transformation that converts ASCII characters to lower
+ case."""
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the Lower to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "Lower":
+ """Creates a Lower from a dictionary."""
+ return Lower()
+
+ def __repr__(self) -> str:
+ result = "Lower("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, Lower)
+
+
+class GetPrefix:
+ length: int
+
+ def __init__(
+ self,
+ *,
+ length: int,
+ ):
+ """The Virtual Part Transformation that gets the prefix of a string.
+
+ :param length: If positive, the number of characters to return
+ from the front. If negative, the absolute number of
+ characters to exclude from the end. e.g. GetPrefix(-1)
+ returns all but the last character.
+ """
+ self.length = length
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetPrefix to a dictionary."""
+ return {
+ "length": self.length,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetPrefix":
+ """Creates a GetPrefix from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "length": d["length"],
+ }
+
+ return GetPrefix(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetPrefix("
+ if self.length is not None:
+ result += f"length={repr(self.length)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetPrefix):
+ return False
+ attributes: list[str] = [
+ "length",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetSegment:
+ split: str
+ index: int
+
+ def __init__(
+ self,
+ *,
+ split: str,
+ index: int,
+ ):
+ """The Virtual Part Transformation that splits a string and gets a
+ particular segment of that split.
+
+ :param split: The characters to split on.
+ :param index: The index of the split string result to return. 0
+ represents the segment before the first split character. -1
+ respresents the segment after the last split character.
+ """
+ if (split is not None) and (len(split) < 1):
+ raise ValueError("The size of split must be greater than or equal to 1")
+
+ if (split is not None) and (len(split) > 1):
+ raise ValueError("The size of split must be less than or equal to 1")
+
+ self.split = split
+ self.index = index
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetSegment to a dictionary."""
+ return {
+ "split": self.split,
+ "index": self.index,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetSegment":
+ """Creates a GetSegment from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "split": d["split"],
+ "index": d["index"],
+ }
+
+ return GetSegment(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetSegment("
+ if self.split is not None:
+ result += f"split={repr(self.split)}, "
+
+ if self.index is not None:
+ result += f"index={repr(self.index)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetSegment):
+ return False
+ attributes: list[str] = [
+ "split",
+ "index",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetSegments:
+ split: str
+ low: int
+ high: int
+
+ def __init__(
+ self,
+ *,
+ split: str,
+ low: int,
+ high: int,
+ ):
+ """The Virtual Part Transformation that splits a string and gets a
+ range of segments of that split.
+
+ :param split: The characters to split on.
+ :param low: The index to start the segments from, inclusive.
+ Negative numbers count from the end. -1 is the last segment.
+ :param high: The index to stop the segments at, exclusive.
+ Negative numbers count from the end. -1 is the last segment.
+ """
+ if (split is not None) and (len(split) < 1):
+ raise ValueError("The size of split must be greater than or equal to 1")
+
+ if (split is not None) and (len(split) > 1):
+ raise ValueError("The size of split must be less than or equal to 1")
+
+ self.split = split
+ self.low = low
+ self.high = high
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetSegments to a dictionary."""
+ return {
+ "split": self.split,
+ "low": self.low,
+ "high": self.high,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetSegments":
+ """Creates a GetSegments from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "split": d["split"],
+ "low": d["low"],
+ "high": d["high"],
+ }
+
+ return GetSegments(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetSegments("
+ if self.split is not None:
+ result += f"split={repr(self.split)}, "
+
+ if self.low is not None:
+ result += f"low={repr(self.low)}, "
+
+ if self.high is not None:
+ result += f"high={repr(self.high)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetSegments):
+ return False
+ attributes: list[str] = [
+ "split",
+ "low",
+ "high",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetSubstring:
+ low: int
+ high: int
+
+ def __init__(
+ self,
+ *,
+ low: int,
+ high: int,
+ ):
+ """The Virtual Part Transformation that gets a substring from a string.
+
+ :param low: The index to start the substring from, inclusive.
+ Negative numbers count from the end. -1 is the last
+ character of a string.
+ :param high: The index to stop the substring at, exclusive.
+ Negative numbers count from the end. -1 is the last
+ character of a string.
+ """
+ self.low = low
+ self.high = high
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetSubstring to a dictionary."""
+ return {
+ "low": self.low,
+ "high": self.high,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetSubstring":
+ """Creates a GetSubstring from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "low": d["low"],
+ "high": d["high"],
+ }
+
+ return GetSubstring(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetSubstring("
+ if self.low is not None:
+ result += f"low={repr(self.low)}, "
+
+ if self.high is not None:
+ result += f"high={repr(self.high)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetSubstring):
+ return False
+ attributes: list[str] = [
+ "low",
+ "high",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetSuffix:
+ length: int
+
+ def __init__(
+ self,
+ *,
+ length: int,
+ ):
+ """The Virtual Part Transformation that gets the suffix of a string.
+
+ :param length: If positive, the number of characters to return
+ from the end. If negative, the absolute number of characters
+ to exclude from the front. e.g. GetSuffix(-1) returns all
+ but the first character.
+ """
+ self.length = length
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetSuffix to a dictionary."""
+ return {
+ "length": self.length,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetSuffix":
+ """Creates a GetSuffix from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "length": d["length"],
+ }
+
+ return GetSuffix(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetSuffix("
+ if self.length is not None:
+ result += f"length={repr(self.length)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetSuffix):
+ return False
+ attributes: list[str] = [
+ "length",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Upper:
+ """The Virtual Part Transformation that converts ASCII characters to upper
+ case."""
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the Upper to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "Upper":
+ """Creates a Upper from a dictionary."""
+ return Upper()
+
+ def __repr__(self) -> str:
+ result = "Upper("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, Upper)
+
+
+class VirtualTransformUpper:
+ """The Virtual Part Transformation that converts ASCII characters to upper
+ case."""
+
+ def __init__(self, value: Upper):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"upper": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformUpper":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformUpper(Upper.from_dict(d["upper"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformUpper(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformUpper):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformLower:
+ """The Virtual Part Transformation that converts ASCII characters to lower
+ case."""
+
+ def __init__(self, value: Lower):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"lower": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformLower":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformLower(Lower.from_dict(d["lower"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformLower(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformLower):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformInsert:
+ """The Virtual Part Transformation that appends a literal string."""
+
+ def __init__(self, value: Insert):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"insert": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformInsert":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformInsert(Insert.from_dict(d["insert"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformInsert(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformInsert):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformPrefix:
+ """The Virtual Part Transformation that gets the prefix of a string."""
+
+ def __init__(self, value: GetPrefix):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"prefix": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformPrefix":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformPrefix(GetPrefix.from_dict(d["prefix"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformPrefix(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformPrefix):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformSuffix:
+ """The Virtual Part Transformation that gets the suffix of a string."""
+
+ def __init__(self, value: GetSuffix):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"suffix": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformSuffix":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformSuffix(GetSuffix.from_dict(d["suffix"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformSuffix(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformSuffix):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformSubstring:
+ """The Virtual Part Transformation that gets a substring from a string."""
+
+ def __init__(self, value: GetSubstring):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"substring": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformSubstring":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformSubstring(GetSubstring.from_dict(d["substring"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformSubstring(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformSubstring):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformSegment:
+ """The Virtual Part Transformation that splits a string and gets a
+ particular segment of that split."""
+
+ def __init__(self, value: GetSegment):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"segment": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformSegment":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformSegment(GetSegment.from_dict(d["segment"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformSegment(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformSegment):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformSegments:
+ """The Virtual Part Transformation that splits a string and gets a range of
+ segments of that split."""
+
+ def __init__(self, value: GetSegments):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"segments": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformSegments":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return VirtualTransformSegments(GetSegments.from_dict(d["segments"]))
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformSegments(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualTransformSegments):
+ return False
+ return self.value == other.value
+
+
+class VirtualTransformUnknown:
+ """Represents an unknown variant.
+
+ If you receive this value, you will need to update your library to
+ receive the parsed value.
+
+ This value may not be deliberately sent.
+ """
+
+ def __init__(self, tag: str):
+ self.tag = tag
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"SDK_UNKNOWN_MEMBER": {"name": self.tag}}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualTransformUnknown":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+ return VirtualTransformUnknown(d["SDK_UNKNOWN_MEMBER"]["name"])
+
+ def __repr__(self) -> str:
+ return f"VirtualTransformUnknown(tag={self.tag})"
+
+
+VirtualTransform = Union[
+ VirtualTransformUpper,
+ VirtualTransformLower,
+ VirtualTransformInsert,
+ VirtualTransformPrefix,
+ VirtualTransformSuffix,
+ VirtualTransformSubstring,
+ VirtualTransformSegment,
+ VirtualTransformSegments,
+ VirtualTransformUnknown,
+]
+
+
+def _virtual_transform_from_dict(d: Dict[str, Any]) -> VirtualTransform:
+ if "upper" in d:
+ return VirtualTransformUpper.from_dict(d)
+
+ if "lower" in d:
+ return VirtualTransformLower.from_dict(d)
+
+ if "insert" in d:
+ return VirtualTransformInsert.from_dict(d)
+
+ if "prefix" in d:
+ return VirtualTransformPrefix.from_dict(d)
+
+ if "suffix" in d:
+ return VirtualTransformSuffix.from_dict(d)
+
+ if "substring" in d:
+ return VirtualTransformSubstring.from_dict(d)
+
+ if "segment" in d:
+ return VirtualTransformSegment.from_dict(d)
+
+ if "segments" in d:
+ return VirtualTransformSegments.from_dict(d)
+
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+
+class VirtualPart:
+ loc: str
+ trans: Optional[list[VirtualTransform]]
+
+ def __init__(
+ self,
+ *,
+ loc: str,
+ trans: Optional[list[VirtualTransform]] = None,
+ ):
+ """A Virtual Part is the configuration of a transformation on an
+ existing field in an item.
+
+ :param loc: The DynamoDB document path to the value for this
+ part.
+ :param trans: A list of transformations performed on the value
+ for this part.
+ """
+ if (loc is not None) and (len(loc) < 1):
+ raise ValueError("The size of loc must be greater than or equal to 1")
+
+ self.loc = loc
+ if (trans is not None) and (len(trans) < 1):
+ raise ValueError("The size of trans must be greater than or equal to 1")
+
+ self.trans = trans
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the VirtualPart to a dictionary."""
+ d: Dict[str, Any] = {
+ "loc": self.loc,
+ }
+
+ if self.trans is not None:
+ d["trans"] = (_virtual_transform_list_as_dict(self.trans),)
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualPart":
+ """Creates a VirtualPart from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "loc": d["loc"],
+ }
+
+ if "trans" in d:
+ kwargs["trans"] = (_virtual_transform_list_from_dict(d["trans"]),)
+
+ return VirtualPart(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "VirtualPart("
+ if self.loc is not None:
+ result += f"loc={repr(self.loc)}, "
+
+ if self.trans is not None:
+ result += f"trans={repr(self.trans)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualPart):
+ return False
+ attributes: list[str] = [
+ "loc",
+ "trans",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class VirtualField:
+ name: str
+ parts: list[VirtualPart]
+
+ def __init__(
+ self,
+ *,
+ name: str,
+ parts: list[VirtualPart],
+ ):
+ """The configuration for a Virtual Field. A Virtual Field is a field
+ constructed from parts of other fields for use with beacons, but never
+ itself stored on items.
+
+ :param name: The name of the Virtual Field.
+ :param parts: The list of ordered parts that make up a Virtual
+ Field.
+ """
+ self.name = name
+ if (parts is not None) and (len(parts) < 1):
+ raise ValueError("The size of parts must be greater than or equal to 1")
+
+ self.parts = parts
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the VirtualField to a dictionary."""
+ return {
+ "name": self.name,
+ "parts": _virtual_part_list_as_dict(self.parts),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "VirtualField":
+ """Creates a VirtualField from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "name": d["name"],
+ "parts": _virtual_part_list_from_dict(d["parts"]),
+ }
+
+ return VirtualField(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "VirtualField("
+ if self.name is not None:
+ result += f"name={repr(self.name)}, "
+
+ if self.parts is not None:
+ result += f"parts={repr(self.parts)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, VirtualField):
+ return False
+ attributes: list[str] = [
+ "name",
+ "parts",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BeaconVersion:
+ version: int
+ key_store: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.client.KeyStore"
+ key_source: BeaconKeySource
+ standard_beacons: list[StandardBeacon]
+ compound_beacons: Optional[list[CompoundBeacon]]
+ virtual_fields: Optional[list[VirtualField]]
+ encrypted_parts: Optional[list[EncryptedPart]]
+ signed_parts: Optional[list[SignedPart]]
+
+ def __init__(
+ self,
+ *,
+ key_store: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.client.KeyStore",
+ key_source: BeaconKeySource,
+ standard_beacons: list[StandardBeacon],
+ version: int = 0,
+ compound_beacons: Optional[list[CompoundBeacon]] = None,
+ virtual_fields: Optional[list[VirtualField]] = None,
+ encrypted_parts: Optional[list[EncryptedPart]] = None,
+ signed_parts: Optional[list[SignedPart]] = None,
+ ):
+ """The configuration for a particular version of searchable encryption.
+ Currently the only supported version is '1'.
+
+ :param key_store: The Key Store that contains the Beacon Keys to
+ use with searchable encryption.
+ :param key_source: The configuration for what beacon key(s) to
+ use.
+ :param standard_beacons: The Standard Beacons to be written with
+ items.
+ :param version: The version of searchable encryption configured.
+ This must be '1'.
+ :param compound_beacons: The Compound Beacons to be written with
+ items.
+ :param virtual_fields: The Virtual Fields to be calculated,
+ supporting other searchable enryption configurations.
+ :param encrypted_parts: The list of Encrypted Parts that may be
+ included in any compound beacon.
+ :param signed_parts: The list of Signed Parts that may be
+ included in any compound beacon.
+ """
+ self.key_store = key_store
+ self.key_source = key_source
+ if (standard_beacons is not None) and (len(standard_beacons) < 1):
+ raise ValueError("The size of standard_beacons must be greater than or equal to 1")
+
+ self.standard_beacons = standard_beacons
+ if (version is not None) and (version < 1):
+ raise ValueError("version must be greater than or equal to 1")
+
+ self.version = version
+ if (compound_beacons is not None) and (len(compound_beacons) < 1):
+ raise ValueError("The size of compound_beacons must be greater than or equal to 1")
+
+ self.compound_beacons = compound_beacons
+ if (virtual_fields is not None) and (len(virtual_fields) < 1):
+ raise ValueError("The size of virtual_fields must be greater than or equal to 1")
+
+ self.virtual_fields = virtual_fields
+ if (encrypted_parts is not None) and (len(encrypted_parts) < 1):
+ raise ValueError("The size of encrypted_parts must be greater than or equal to 1")
+
+ self.encrypted_parts = encrypted_parts
+ if (signed_parts is not None) and (len(signed_parts) < 1):
+ raise ValueError("The size of signed_parts must be greater than or equal to 1")
+
+ self.signed_parts = signed_parts
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BeaconVersion to a dictionary."""
+ d: Dict[str, Any] = {
+ "key_store": self.key_store.as_dict(),
+ "key_source": self.key_source.as_dict(),
+ "standard_beacons": _standard_beacon_list_as_dict(self.standard_beacons),
+ }
+
+ if self.version is not None:
+ d["version"] = self.version
+
+ if self.compound_beacons is not None:
+ d["compound_beacons"] = (_compound_beacon_list_as_dict(self.compound_beacons),)
+
+ if self.virtual_fields is not None:
+ d["virtual_fields"] = (_virtual_field_list_as_dict(self.virtual_fields),)
+
+ if self.encrypted_parts is not None:
+ d["encrypted_parts"] = (_encrypted_parts_list_as_dict(self.encrypted_parts),)
+
+ if self.signed_parts is not None:
+ d["signed_parts"] = (_signed_parts_list_as_dict(self.signed_parts),)
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BeaconVersion":
+ """Creates a BeaconVersion from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_keystore.client import (
+ KeyStore,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "key_store": KeyStore.from_dict(d["key_store"]),
+ "key_source": _beacon_key_source_from_dict(d["key_source"]),
+ "standard_beacons": _standard_beacon_list_from_dict(d["standard_beacons"]),
+ }
+
+ if "version" in d:
+ kwargs["version"] = d["version"]
+
+ if "compound_beacons" in d:
+ kwargs["compound_beacons"] = (_compound_beacon_list_from_dict(d["compound_beacons"]),)
+
+ if "virtual_fields" in d:
+ kwargs["virtual_fields"] = (_virtual_field_list_from_dict(d["virtual_fields"]),)
+
+ if "encrypted_parts" in d:
+ kwargs["encrypted_parts"] = (_encrypted_parts_list_from_dict(d["encrypted_parts"]),)
+
+ if "signed_parts" in d:
+ kwargs["signed_parts"] = (_signed_parts_list_from_dict(d["signed_parts"]),)
+
+ return BeaconVersion(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BeaconVersion("
+ if self.version is not None:
+ result += f"version={repr(self.version)}, "
+
+ if self.key_store is not None:
+ result += f"key_store={repr(self.key_store)}, "
+
+ if self.key_source is not None:
+ result += f"key_source={repr(self.key_source)}, "
+
+ if self.standard_beacons is not None:
+ result += f"standard_beacons={repr(self.standard_beacons)}, "
+
+ if self.compound_beacons is not None:
+ result += f"compound_beacons={repr(self.compound_beacons)}, "
+
+ if self.virtual_fields is not None:
+ result += f"virtual_fields={repr(self.virtual_fields)}, "
+
+ if self.encrypted_parts is not None:
+ result += f"encrypted_parts={repr(self.encrypted_parts)}, "
+
+ if self.signed_parts is not None:
+ result += f"signed_parts={repr(self.signed_parts)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BeaconVersion):
+ return False
+ attributes: list[str] = [
+ "version",
+ "key_store",
+ "key_source",
+ "standard_beacons",
+ "compound_beacons",
+ "virtual_fields",
+ "encrypted_parts",
+ "signed_parts",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class LegacyPolicy:
+ FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT = "FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT"
+
+ FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT = "FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT"
+
+ FORBID_LEGACY_ENCRYPT_FORBID_LEGACY_DECRYPT = "FORBID_LEGACY_ENCRYPT_FORBID_LEGACY_DECRYPT"
+
+ # This set contains every possible value known at the time this was generated. New
+ # values may be added in the future.
+ values = frozenset(
+ {
+ "FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT",
+ "FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT",
+ "FORBID_LEGACY_ENCRYPT_FORBID_LEGACY_DECRYPT",
+ }
+ )
+
+
+class LegacyOverride:
+ policy: str
+ encryptor: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references.LegacyDynamoDbEncryptor"
+ attribute_actions_on_encrypt: dict[str, str]
+ default_attribute_flag: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ policy: str,
+ encryptor: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references.LegacyDynamoDbEncryptor",
+ attribute_actions_on_encrypt: dict[str, str],
+ default_attribute_flag: Optional[str] = None,
+ ):
+ """A configuration for overriding encryption and/or decryption to
+ instead perform legacy encryption and decryption.
+
+ :param policy: A policy which configurates whether legacy
+ behavior overrides encryption and/or decryption.
+ :param encryptor: A configuration for the legacy DynamoDB
+ Encryption Client's Encryptor.
+ :param attribute_actions_on_encrypt: Overrides which attributes
+ are encrypted and/or signed for any items read or written
+ with legacy behavior.
+ :param default_attribute_flag: This input is not used in the
+ Java Client and should not be specified.
+ """
+ self.policy = policy
+ self.encryptor = encryptor
+ self.attribute_actions_on_encrypt = attribute_actions_on_encrypt
+ self.default_attribute_flag = default_attribute_flag
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the LegacyOverride to a dictionary."""
+ d: Dict[str, Any] = {
+ "policy": self.policy,
+ "encryptor": self.encryptor.as_dict(),
+ "attribute_actions_on_encrypt": self.attribute_actions_on_encrypt,
+ }
+
+ if self.default_attribute_flag is not None:
+ d["default_attribute_flag"] = self.default_attribute_flag
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "LegacyOverride":
+ """Creates a LegacyOverride from a dictionary."""
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.references import (
+ LegacyDynamoDbEncryptor,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "policy": d["policy"],
+ "encryptor": LegacyDynamoDbEncryptor.from_dict(d["encryptor"]),
+ "attribute_actions_on_encrypt": d["attribute_actions_on_encrypt"],
+ }
+
+ if "default_attribute_flag" in d:
+ kwargs["default_attribute_flag"] = d["default_attribute_flag"]
+
+ return LegacyOverride(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "LegacyOverride("
+ if self.policy is not None:
+ result += f"policy={repr(self.policy)}, "
+
+ if self.encryptor is not None:
+ result += f"encryptor={repr(self.encryptor)}, "
+
+ if self.attribute_actions_on_encrypt is not None:
+ result += f"attribute_actions_on_encrypt={repr(self.attribute_actions_on_encrypt)}, "
+
+ if self.default_attribute_flag is not None:
+ result += f"default_attribute_flag={repr(self.default_attribute_flag)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, LegacyOverride):
+ return False
+ attributes: list[str] = [
+ "policy",
+ "encryptor",
+ "attribute_actions_on_encrypt",
+ "default_attribute_flag",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PlaintextOverride:
+ FORCE_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ = "FORCE_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ"
+
+ FORBID_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ = "FORBID_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ"
+
+ FORBID_PLAINTEXT_WRITE_FORBID_PLAINTEXT_READ = "FORBID_PLAINTEXT_WRITE_FORBID_PLAINTEXT_READ"
+
+ # This set contains every possible value known at the time this was generated. New
+ # values may be added in the future.
+ values = frozenset(
+ {
+ "FORCE_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ",
+ "FORBID_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ",
+ "FORBID_PLAINTEXT_WRITE_FORBID_PLAINTEXT_READ",
+ }
+ )
+
+
+class SearchConfig:
+ versions: list[BeaconVersion]
+ write_version: int
+
+ def __init__(
+ self,
+ *,
+ versions: list[BeaconVersion],
+ write_version: int = 0,
+ ):
+ """The configuration for searchable encryption.
+
+ :param versions: The versions of searchable encryption to
+ support reading. Currently must contain a single
+ configuration with version '1'.
+ :param write_version: The searchable encryption version to use
+ when writing new items. Must be '1'.
+ """
+ if (versions is not None) and (len(versions) < 1):
+ raise ValueError("The size of versions must be greater than or equal to 1")
+
+ if (versions is not None) and (len(versions) > 1):
+ raise ValueError("The size of versions must be less than or equal to 1")
+
+ self.versions = versions
+ if (write_version is not None) and (write_version < 1):
+ raise ValueError("write_version must be greater than or equal to 1")
+
+ self.write_version = write_version
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the SearchConfig to a dictionary."""
+ d: Dict[str, Any] = {
+ "versions": _beacon_version_list_as_dict(self.versions),
+ }
+
+ if self.write_version is not None:
+ d["write_version"] = self.write_version
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "SearchConfig":
+ """Creates a SearchConfig from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "versions": _beacon_version_list_from_dict(d["versions"]),
+ }
+
+ if "write_version" in d:
+ kwargs["write_version"] = d["write_version"]
+
+ return SearchConfig(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "SearchConfig("
+ if self.versions is not None:
+ result += f"versions={repr(self.versions)}, "
+
+ if self.write_version is not None:
+ result += f"write_version={repr(self.write_version)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, SearchConfig):
+ return False
+ attributes: list[str] = [
+ "versions",
+ "write_version",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DynamoDbTableEncryptionConfig:
+ logical_table_name: str
+ partition_key_name: str
+ sort_key_name: Optional[str]
+ search: Optional[SearchConfig]
+ attribute_actions_on_encrypt: dict[str, str]
+ allowed_unsigned_attributes: Optional[list[str]]
+ allowed_unsigned_attribute_prefix: Optional[str]
+ algorithm_suite_id: Optional[str]
+ keyring: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.Keyring"
+ ]
+ cmm: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ ]
+ legacy_override: Optional[LegacyOverride]
+ plaintext_override: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ logical_table_name: str,
+ partition_key_name: str,
+ attribute_actions_on_encrypt: dict[str, str],
+ sort_key_name: Optional[str] = None,
+ search: Optional[SearchConfig] = None,
+ allowed_unsigned_attributes: Optional[list[str]] = None,
+ allowed_unsigned_attribute_prefix: Optional[str] = None,
+ algorithm_suite_id: Optional[str] = None,
+ keyring: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.Keyring"
+ ] = None,
+ cmm: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ ] = None,
+ legacy_override: Optional[LegacyOverride] = None,
+ plaintext_override: Optional[str] = None,
+ ):
+ """The configuration for client-side encryption for a particular
+ DynamoDB table.
+
+ :param logical_table_name: The logical table name for this
+ table. This is the name that is cryptographically bound with
+ your data. This can be the same as the actual DynamoDB table
+ name. It's purpose is to be distinct from the DynamoDB table
+ name so that the data may still be authenticated if being
+ read from different (but logically similar) tables, such as
+ a backup table.
+ :param partition_key_name: The name of the partition key on this
+ table.
+ :param attribute_actions_on_encrypt: A map that describes what
+ attributes should be encrypted and/or signed on encrypt.
+ This map must contain all attributes that might be
+ encountered during encryption.
+ :param sort_key_name: If this table contains a sort key, the
+ name of the sort key on this table.
+ :param search: The configuration for searchable encryption.
+ :param allowed_unsigned_attributes: A list of attribute names
+ such that, if encountered during decryption, those
+ attributes are treated as unsigned.
+ :param allowed_unsigned_attribute_prefix: A prefix such that, if
+ during decryption any attribute has a name with this prefix,
+ it is treated as unsigned.
+ :param algorithm_suite_id: An ID for the algorithm suite to use
+ during encryption and decryption.
+ :param keyring: The Keyring that should be used to wrap and
+ unwrap data keys. If specified a Default Cryptographic
+ Materials Manager with this Keyring is used to obtain
+ materials for encryption and decryption. Either a Keyring or
+ a Cryptographic Materials Manager must be specified.
+ :param cmm: The Cryptographic Materials Manager that is used to
+ obtain materials for encryption and decryption. Either a
+ Keyring or a Cryptographic Materials Manager must be
+ specified.
+ :param legacy_override: A configuration that override encryption
+ and/or decryption to instead perform legacy encryption
+ and/or decryption. Used as part of migration from version
+ 2.x to version 3.x.
+ :param plaintext_override: A configuration that override
+ encryption and/or decryption to instead passthrough and
+ write and/or read plaintext. Used to update plaintext tables
+ to fully use client-side encryption.
+ """
+ self.logical_table_name = logical_table_name
+ if (partition_key_name is not None) and (len(partition_key_name) < 1):
+ raise ValueError("The size of partition_key_name must be greater than or equal to 1")
+
+ if (partition_key_name is not None) and (len(partition_key_name) > 255):
+ raise ValueError("The size of partition_key_name must be less than or equal to 255")
+
+ self.partition_key_name = partition_key_name
+ self.attribute_actions_on_encrypt = attribute_actions_on_encrypt
+ if (sort_key_name is not None) and (len(sort_key_name) < 1):
+ raise ValueError("The size of sort_key_name must be greater than or equal to 1")
+
+ if (sort_key_name is not None) and (len(sort_key_name) > 255):
+ raise ValueError("The size of sort_key_name must be less than or equal to 255")
+
+ self.sort_key_name = sort_key_name
+ self.search = search
+ if (allowed_unsigned_attributes is not None) and (len(allowed_unsigned_attributes) < 1):
+ raise ValueError("The size of allowed_unsigned_attributes must be greater than or equal to 1")
+
+ self.allowed_unsigned_attributes = allowed_unsigned_attributes
+ self.allowed_unsigned_attribute_prefix = allowed_unsigned_attribute_prefix
+ self.algorithm_suite_id = algorithm_suite_id
+ self.keyring = keyring
+ self.cmm = cmm
+ self.legacy_override = legacy_override
+ self.plaintext_override = plaintext_override
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbTableEncryptionConfig to a dictionary."""
+ d: Dict[str, Any] = {
+ "logical_table_name": self.logical_table_name,
+ "partition_key_name": self.partition_key_name,
+ "attribute_actions_on_encrypt": self.attribute_actions_on_encrypt,
+ }
+
+ if self.sort_key_name is not None:
+ d["sort_key_name"] = self.sort_key_name
+
+ if self.search is not None:
+ d["search"] = self.search.as_dict()
+
+ if self.allowed_unsigned_attributes is not None:
+ d["allowed_unsigned_attributes"] = self.allowed_unsigned_attributes
+
+ if self.allowed_unsigned_attribute_prefix is not None:
+ d["allowed_unsigned_attribute_prefix"] = self.allowed_unsigned_attribute_prefix
+
+ if self.algorithm_suite_id is not None:
+ d["algorithm_suite_id"] = self.algorithm_suite_id
+
+ if self.keyring is not None:
+ d["keyring"] = self.keyring.as_dict()
+
+ if self.cmm is not None:
+ d["cmm"] = self.cmm.as_dict()
+
+ if self.legacy_override is not None:
+ d["legacy_override"] = self.legacy_override.as_dict()
+
+ if self.plaintext_override is not None:
+ d["plaintext_override"] = self.plaintext_override
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbTableEncryptionConfig":
+ """Creates a DynamoDbTableEncryptionConfig from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ Keyring,
+ )
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "logical_table_name": d["logical_table_name"],
+ "partition_key_name": d["partition_key_name"],
+ "attribute_actions_on_encrypt": d["attribute_actions_on_encrypt"],
+ }
+
+ if "sort_key_name" in d:
+ kwargs["sort_key_name"] = d["sort_key_name"]
+
+ if "search" in d:
+ kwargs["search"] = SearchConfig.from_dict(d["search"])
+
+ if "allowed_unsigned_attributes" in d:
+ kwargs["allowed_unsigned_attributes"] = d["allowed_unsigned_attributes"]
+
+ if "allowed_unsigned_attribute_prefix" in d:
+ kwargs["allowed_unsigned_attribute_prefix"] = d["allowed_unsigned_attribute_prefix"]
+
+ if "algorithm_suite_id" in d:
+ kwargs["algorithm_suite_id"] = d["algorithm_suite_id"]
+
+ if "keyring" in d:
+ kwargs["keyring"] = Keyring.from_dict(d["keyring"])
+
+ if "cmm" in d:
+ kwargs["cmm"] = CryptographicMaterialsManager.from_dict(d["cmm"])
+
+ if "legacy_override" in d:
+ kwargs["legacy_override"] = LegacyOverride.from_dict(d["legacy_override"])
+
+ if "plaintext_override" in d:
+ kwargs["plaintext_override"] = d["plaintext_override"]
+
+ return DynamoDbTableEncryptionConfig(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbTableEncryptionConfig("
+ if self.logical_table_name is not None:
+ result += f"logical_table_name={repr(self.logical_table_name)}, "
+
+ if self.partition_key_name is not None:
+ result += f"partition_key_name={repr(self.partition_key_name)}, "
+
+ if self.sort_key_name is not None:
+ result += f"sort_key_name={repr(self.sort_key_name)}, "
+
+ if self.search is not None:
+ result += f"search={repr(self.search)}, "
+
+ if self.attribute_actions_on_encrypt is not None:
+ result += f"attribute_actions_on_encrypt={repr(self.attribute_actions_on_encrypt)}, "
+
+ if self.allowed_unsigned_attributes is not None:
+ result += f"allowed_unsigned_attributes={repr(self.allowed_unsigned_attributes)}, "
+
+ if self.allowed_unsigned_attribute_prefix is not None:
+ result += f"allowed_unsigned_attribute_prefix={repr(self.allowed_unsigned_attribute_prefix)}, "
+
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.keyring is not None:
+ result += f"keyring={repr(self.keyring)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.legacy_override is not None:
+ result += f"legacy_override={repr(self.legacy_override)}, "
+
+ if self.plaintext_override is not None:
+ result += f"plaintext_override={repr(self.plaintext_override)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbTableEncryptionConfig):
+ return False
+ attributes: list[str] = [
+ "logical_table_name",
+ "partition_key_name",
+ "sort_key_name",
+ "search",
+ "attribute_actions_on_encrypt",
+ "allowed_unsigned_attributes",
+ "allowed_unsigned_attribute_prefix",
+ "algorithm_suite_id",
+ "keyring",
+ "cmm",
+ "legacy_override",
+ "plaintext_override",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DynamoDbTablesEncryptionConfig:
+ table_encryption_configs: dict[str, DynamoDbTableEncryptionConfig]
+
+ def __init__(
+ self,
+ *,
+ table_encryption_configs: dict[str, DynamoDbTableEncryptionConfig],
+ ):
+ """The configuration for client-side encryption with multiple DynamoDB
+ table.
+
+ :param table_encryption_configs: A map of DynamoDB table name to
+ its configuration for client-side encryption.
+ """
+ self.table_encryption_configs = table_encryption_configs
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbTablesEncryptionConfig to a dictionary."""
+ return {
+ "table_encryption_configs": _dynamo_db_table_encryption_config_list_as_dict(self.table_encryption_configs),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbTablesEncryptionConfig":
+ """Creates a DynamoDbTablesEncryptionConfig from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "table_encryption_configs": _dynamo_db_table_encryption_config_list_from_dict(
+ d["table_encryption_configs"]
+ ),
+ }
+
+ return DynamoDbTablesEncryptionConfig(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbTablesEncryptionConfig("
+ if self.table_encryption_configs is not None:
+ result += f"table_encryption_configs={repr(self.table_encryption_configs)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbTablesEncryptionConfig):
+ return False
+ attributes: list[str] = [
+ "table_encryption_configs",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _encrypted_data_key_description_list_as_dict(
+ given: list[EncryptedDataKeyDescription],
+) -> List[Any]:
+ return [v.as_dict() for v in given]
+
+
+def _encrypted_data_key_description_list_from_dict(
+ given: List[Any],
+) -> list[EncryptedDataKeyDescription]:
+ return [EncryptedDataKeyDescription.from_dict(v) for v in given]
+
+
+class Unit:
+ pass
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/plugin.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/plugin.py
new file mode 100644
index 000000000..e4c614d01
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/plugin.py
@@ -0,0 +1,49 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from .config import (
+ Config,
+ Plugin,
+ smithy_config_to_dafny_config,
+ DynamoDbEncryptionConfig,
+)
+from smithy_python.interfaces.retries import RetryStrategy
+from smithy_python.exceptions import SmithyRetryException
+from .dafnyImplInterface import DafnyImplInterface
+
+
+def set_config_impl(config: Config):
+ """Set the Dafny-compiled implementation in the Smithy-Python client Config
+ and load our custom NoRetriesStrategy."""
+ config.dafnyImplInterface = DafnyImplInterface()
+ if isinstance(config, DynamoDbEncryptionConfig):
+ from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbEncryption import (
+ default__,
+ )
+
+ config.dafnyImplInterface.impl = default__.DynamoDbEncryption(smithy_config_to_dafny_config(config)).value
+ config.retry_strategy = NoRetriesStrategy()
+
+
+class ZeroRetryDelayToken:
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not wait to retry.
+ """
+
+ retry_delay = 0
+
+
+class NoRetriesStrategy(RetryStrategy):
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not retry calling Dafny code.
+ """
+
+ def acquire_initial_retry_token(self):
+ return ZeroRetryDelayToken()
+
+ def refresh_retry_token_for_retry(self, token_to_renew, error_info):
+ # Do not retry
+ raise SmithyRetryException()
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/references.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/references.py
new file mode 100644
index 000000000..66e8de9cb
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/references.py
@@ -0,0 +1,142 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import abc
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ GetBranchKeyIdFromDdbKeyInput_GetBranchKeyIdFromDdbKeyInput as DafnyGetBranchKeyIdFromDdbKeyInput,
+ GetBranchKeyIdFromDdbKeyOutput_GetBranchKeyIdFromDdbKeyOutput as DafnyGetBranchKeyIdFromDdbKeyOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors import (
+ _smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+from smithy_dafny_standard_library.internaldafny.generated import Wrappers
+from typing import Any, Dict
+
+
+class ILegacyDynamoDbEncryptor(metaclass=abc.ABCMeta):
+
+ @classmethod
+ def __subclasshook__(cls, subclass):
+ return ()
+
+
+class LegacyDynamoDbEncryptor(ILegacyDynamoDbEncryptor):
+
+ _impl: (
+ aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.ILegacyDynamoDbEncryptor
+ )
+
+ def __init__(
+ self,
+ _impl: aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.ILegacyDynamoDbEncryptor,
+ ):
+ self._impl = _impl
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "LegacyDynamoDbEncryptor":
+ return LegacyDynamoDbEncryptor(d["_impl"])
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"_impl": self._impl}
+
+
+class IDynamoDbKeyBranchKeyIdSupplier(metaclass=abc.ABCMeta):
+
+ @classmethod
+ def __subclasshook__(cls, subclass):
+ return hasattr(subclass, "GetBranchKeyIdFromDdbKey") and callable(subclass.GetBranchKeyIdFromDdbKey)
+
+ @abc.abstractmethod
+ def get_branch_key_id_from_ddb_key(
+ self,
+ param: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyInput",
+ ) -> "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyOutput":
+ """Get the Branch Key that should be used for wrapping and unwrapping
+ data keys based on the primary key of the item being read or written,
+ along with the values of any attributes configured as
+ SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT.
+
+ :param param: Inputs for getting the Branch Key that should be
+ used for wrapping and unwrapping data keys.
+ :returns: Outputs for getting the Branch Key that should be used
+ for wrapping and unwrapping data keys.
+ """
+ raise NotImplementedError
+
+ def GetBranchKeyIdFromDdbKey(
+ self, dafny_input: "DafnyGetBranchKeyIdFromDdbKeyInput"
+ ) -> "DafnyGetBranchKeyIdFromDdbKeyOutput":
+ """Do not use.
+
+ This method allows custom implementations of this interface to
+ interact with generated code.
+ """
+ native_input = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyInput(
+ dafny_input
+ )
+ try:
+ native_output = self.get_branch_key_id_from_ddb_key(native_input)
+ dafny_output = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyOutput(
+ native_output
+ )
+ return Wrappers.Result_Success(dafny_output)
+ except Exception as e:
+ error = _smithy_error_to_dafny_error(e)
+ return Wrappers.Result_Failure(error)
+
+
+class DynamoDbKeyBranchKeyIdSupplier(IDynamoDbKeyBranchKeyIdSupplier):
+
+ _impl: (
+ aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.IDynamoDbKeyBranchKeyIdSupplier
+ )
+
+ def __init__(
+ self,
+ _impl: aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.IDynamoDbKeyBranchKeyIdSupplier,
+ ):
+ self._impl = _impl
+
+ def get_branch_key_id_from_ddb_key(
+ self,
+ param: "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyInput",
+ ) -> "aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetBranchKeyIdFromDdbKeyOutput":
+ """Get the Branch Key that should be used for wrapping and unwrapping
+ data keys based on the primary key of the item being read or written,
+ along with the values of any attributes configured as
+ SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT.
+
+ :param param: Inputs for getting the Branch Key that should be
+ used for wrapping and unwrapping data keys.
+ :returns: Outputs for getting the Branch Key that should be used
+ for wrapping and unwrapping data keys.
+ """
+ dafny_output = self._impl.GetBranchKeyIdFromDdbKey(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyInput(
+ param
+ )
+ )
+ if dafny_output.IsFailure():
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error,
+ )
+
+ raise aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error(dafny_output.error)
+
+ else:
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyOutput(
+ dafny_output.value
+ )
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbKeyBranchKeyIdSupplier":
+ return DynamoDbKeyBranchKeyIdSupplier(d["_impl"])
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"_impl": self._impl}
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/serialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/serialize.py
new file mode 100644
index 000000000..69429dbfa
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/serialize.py
@@ -0,0 +1,27 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+
+from .dafny_protocol import DafnyRequest
+
+from .config import Config
+
+
+def _serialize_create_dynamo_db_encryption_branch_key_id_supplier(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="CreateDynamoDbEncryptionBranchKeyIdSupplier",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ input
+ ),
+ )
+
+
+def _serialize_get_encrypted_data_key_description(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="GetEncryptedDataKeyDescription",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionInput(
+ input
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/smithy_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/smithy_to_dafny.py
new file mode 100644
index 000000000..535d2dff4
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/smithy_to_dafny.py
@@ -0,0 +1,1155 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ AsSet_AsSet as DafnyAsSet,
+ BeaconKeySource_multi,
+ BeaconKeySource_single,
+ BeaconStyle_asSet,
+ BeaconStyle_partOnly,
+ BeaconStyle_shared,
+ BeaconStyle_sharedSet,
+ BeaconVersion_BeaconVersion as DafnyBeaconVersion,
+ CompoundBeacon_CompoundBeacon as DafnyCompoundBeacon,
+ ConstructorPart_ConstructorPart as DafnyConstructorPart,
+ Constructor_Constructor as DafnyConstructor,
+ CreateDynamoDbEncryptionBranchKeyIdSupplierInput_CreateDynamoDbEncryptionBranchKeyIdSupplierInput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierInput,
+ CreateDynamoDbEncryptionBranchKeyIdSupplierOutput_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierOutput,
+ DynamoDbEncryptionConfig_DynamoDbEncryptionConfig as DafnyDynamoDbEncryptionConfig,
+ DynamoDbTableEncryptionConfig_DynamoDbTableEncryptionConfig as DafnyDynamoDbTableEncryptionConfig,
+ DynamoDbTablesEncryptionConfig_DynamoDbTablesEncryptionConfig as DafnyDynamoDbTablesEncryptionConfig,
+ EncryptedDataKeyDescription_EncryptedDataKeyDescription as DafnyEncryptedDataKeyDescription,
+ EncryptedPart_EncryptedPart as DafnyEncryptedPart,
+ GetBranchKeyIdFromDdbKeyInput_GetBranchKeyIdFromDdbKeyInput as DafnyGetBranchKeyIdFromDdbKeyInput,
+ GetBranchKeyIdFromDdbKeyOutput_GetBranchKeyIdFromDdbKeyOutput as DafnyGetBranchKeyIdFromDdbKeyOutput,
+ GetEncryptedDataKeyDescriptionInput_GetEncryptedDataKeyDescriptionInput as DafnyGetEncryptedDataKeyDescriptionInput,
+ GetEncryptedDataKeyDescriptionOutput_GetEncryptedDataKeyDescriptionOutput as DafnyGetEncryptedDataKeyDescriptionOutput,
+ GetEncryptedDataKeyDescriptionUnion_header,
+ GetEncryptedDataKeyDescriptionUnion_item,
+ GetPrefix_GetPrefix as DafnyGetPrefix,
+ GetSegment_GetSegment as DafnyGetSegment,
+ GetSegments_GetSegments as DafnyGetSegments,
+ GetSubstring_GetSubstring as DafnyGetSubstring,
+ GetSuffix_GetSuffix as DafnyGetSuffix,
+ Insert_Insert as DafnyInsert,
+ LegacyOverride_LegacyOverride as DafnyLegacyOverride,
+ LegacyPolicy_FORBID__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT,
+ LegacyPolicy_FORBID__LEGACY__ENCRYPT__FORBID__LEGACY__DECRYPT,
+ LegacyPolicy_FORCE__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT,
+ Lower_Lower as DafnyLower,
+ MultiKeyStore_MultiKeyStore as DafnyMultiKeyStore,
+ PartOnly_PartOnly as DafnyPartOnly,
+ PlaintextOverride_FORBID__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ,
+ PlaintextOverride_FORBID__PLAINTEXT__WRITE__FORBID__PLAINTEXT__READ,
+ PlaintextOverride_FORCE__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ,
+ SearchConfig_SearchConfig as DafnySearchConfig,
+ SharedSet_SharedSet as DafnySharedSet,
+ Shared_Shared as DafnyShared,
+ SignedPart_SignedPart as DafnySignedPart,
+ SingleKeyStore_SingleKeyStore as DafnySingleKeyStore,
+ StandardBeacon_StandardBeacon as DafnyStandardBeacon,
+ Upper_Upper as DafnyUpper,
+ VirtualField_VirtualField as DafnyVirtualField,
+ VirtualPart_VirtualPart as DafnyVirtualPart,
+ VirtualTransform_insert,
+ VirtualTransform_lower,
+ VirtualTransform_prefix,
+ VirtualTransform_segment,
+ VirtualTransform_segments,
+ VirtualTransform_substring,
+ VirtualTransform_suffix,
+ VirtualTransform_upper,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny
+from smithy_dafny_standard_library.internaldafny.generated.Wrappers import (
+ Option_None,
+ Option_Some,
+)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyInput(
+ native_input,
+):
+ return DafnyGetBranchKeyIdFromDdbKeyInput(
+ ddbKey=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.ddb_key.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetBranchKeyIdFromDdbKeyOutput(
+ native_input,
+):
+ return DafnyGetBranchKeyIdFromDdbKeyOutput(
+ branchKeyId=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.branch_key_id.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ native_input,
+):
+ return DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ ddbKeyBranchKeyIdSupplier=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbKeyBranchKeyIdSupplierReference(
+ native_input.ddb_key_branch_key_id_supplier
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbKeyBranchKeyIdSupplierReference(
+ native_input,
+):
+ if hasattr(native_input, "_impl"):
+ return native_input._impl
+
+ else:
+ return native_input
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionInput(
+ native_input,
+):
+ return DafnyGetEncryptedDataKeyDescriptionInput(
+ input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionUnion(
+ native_input.input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionUnion(
+ native_input,
+):
+ if isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionUnionHeader,
+ ):
+ GetEncryptedDataKeyDescriptionUnion_union_value = GetEncryptedDataKeyDescriptionUnion_header(
+ Seq(native_input.value)
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionUnionItem,
+ ):
+ GetEncryptedDataKeyDescriptionUnion_union_value = GetEncryptedDataKeyDescriptionUnion_item(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.value.items()
+ }
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return GetEncryptedDataKeyDescriptionUnion_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ native_input,
+):
+ return DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ branchKeyIdSupplier=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_BranchKeyIdSupplierReference(
+ native_input.branch_key_id_supplier
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionOutput(
+ native_input,
+):
+ return DafnyGetEncryptedDataKeyDescriptionOutput(
+ EncryptedDataKeyDescriptionOutput=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedDataKeyDescription(
+ list_element
+ )
+ for list_element in native_input.encrypted_data_key_description_output
+ ]
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_EncryptedDataKeyDescription(native_input):
+ return DafnyEncryptedDataKeyDescription(
+ keyProviderId=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.key_provider_id.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ keyProviderInfo=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.key_provider_info.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.key_provider_info is not None)
+ else (Option_None())
+ ),
+ branchKeyId=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.branch_key_id.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.branch_key_id is not None)
+ else (Option_None())
+ ),
+ branchKeyVersion=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.branch_key_version.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.branch_key_version is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_AsSet(native_input):
+ return DafnyAsSet()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_AtomicPrimitivesReference(native_input):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_MultiKeyStore(native_input):
+ return DafnyMultiKeyStore(
+ keyFieldName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.key_field_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ cacheTTL=native_input.cache_ttl,
+ cache=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CacheType(
+ native_input.cache
+ )
+ )
+ )
+ if (native_input.cache is not None)
+ else (Option_None())
+ ),
+ partitionId=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.partition_id.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.partition_id is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SingleKeyStore(native_input):
+ return DafnySingleKeyStore(
+ keyId=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.key_id.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ cacheTTL=native_input.cache_ttl,
+ cache=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CacheType(
+ native_input.cache
+ )
+ )
+ )
+ if (native_input.cache is not None)
+ else (Option_None())
+ ),
+ partitionId=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.partition_id.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.partition_id is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconKeySource(native_input):
+ if isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconKeySourceSingle,
+ ):
+ BeaconKeySource_union_value = BeaconKeySource_single(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_SingleKeyStore(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconKeySourceMulti,
+ ):
+ BeaconKeySource_union_value = BeaconKeySource_multi(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_MultiKeyStore(
+ native_input.value
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return BeaconKeySource_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_PartOnly(native_input):
+ return DafnyPartOnly()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Shared(native_input):
+ return DafnyShared(
+ other=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.other.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SharedSet(native_input):
+ return DafnySharedSet(
+ other=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.other.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconStyle(native_input):
+ if isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStylePartOnly,
+ ):
+ BeaconStyle_union_value = BeaconStyle_partOnly(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_PartOnly(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleShared,
+ ):
+ BeaconStyle_union_value = BeaconStyle_shared(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_Shared(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleAsSet,
+ ):
+ BeaconStyle_union_value = BeaconStyle_asSet(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_AsSet(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.BeaconStyleSharedSet,
+ ):
+ BeaconStyle_union_value = BeaconStyle_sharedSet(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_SharedSet(
+ native_input.value
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return BeaconStyle_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_ConstructorPart(native_input):
+ return DafnyConstructorPart(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ required=native_input.required,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Constructor(native_input):
+ return DafnyConstructor(
+ parts=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_ConstructorPart(
+ list_element
+ )
+ for list_element in native_input.parts
+ ]
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(native_input):
+ return DafnyEncryptedPart(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ prefix=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.prefix.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(native_input):
+ return DafnySignedPart(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ prefix=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.prefix.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ loc=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.loc.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.loc is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_CompoundBeacon(native_input):
+ return DafnyCompoundBeacon(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ split=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.split.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ encrypted=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(
+ list_element
+ )
+ for list_element in native_input.encrypted
+ ]
+ )
+ )
+ )
+ if (native_input.encrypted is not None)
+ else (Option_None())
+ ),
+ signed=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(
+ list_element
+ )
+ for list_element in native_input.signed
+ ]
+ )
+ )
+ )
+ if (native_input.signed is not None)
+ else (Option_None())
+ ),
+ constructors=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_Constructor(
+ list_element
+ )
+ for list_element in native_input.constructors
+ ]
+ )
+ )
+ )
+ if (native_input.constructors is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_KeyStoreReference(native_input):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_StandardBeacon(native_input):
+ return DafnyStandardBeacon(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ length=native_input.length,
+ loc=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.loc.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.loc is not None)
+ else (Option_None())
+ ),
+ style=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_BeaconStyle(
+ native_input.style
+ )
+ )
+ )
+ if (native_input.style is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Insert(native_input):
+ return DafnyInsert(
+ literal=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.literal.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Lower(native_input):
+ return DafnyLower()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetPrefix(native_input):
+ return DafnyGetPrefix(
+ length=native_input.length,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSegment(native_input):
+ return DafnyGetSegment(
+ split=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.split.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ index=native_input.index,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSegments(native_input):
+ return DafnyGetSegments(
+ split=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.split.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ low=native_input.low,
+ high=native_input.high,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSubstring(native_input):
+ return DafnyGetSubstring(
+ low=native_input.low,
+ high=native_input.high,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_GetSuffix(native_input):
+ return DafnyGetSuffix(
+ length=native_input.length,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_Upper(native_input):
+ return DafnyUpper()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualTransform(native_input):
+ if isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformUpper,
+ ):
+ VirtualTransform_union_value = VirtualTransform_upper(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_Upper(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformLower,
+ ):
+ VirtualTransform_union_value = VirtualTransform_lower(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_Lower(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformInsert,
+ ):
+ VirtualTransform_union_value = VirtualTransform_insert(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_Insert(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformPrefix,
+ ):
+ VirtualTransform_union_value = VirtualTransform_prefix(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetPrefix(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSuffix,
+ ):
+ VirtualTransform_union_value = VirtualTransform_suffix(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetSuffix(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSubstring,
+ ):
+ VirtualTransform_union_value = VirtualTransform_substring(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetSubstring(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSegment,
+ ):
+ VirtualTransform_union_value = VirtualTransform_segment(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetSegment(
+ native_input.value
+ )
+ )
+ elif isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.VirtualTransformSegments,
+ ):
+ VirtualTransform_union_value = VirtualTransform_segments(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetSegments(
+ native_input.value
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return VirtualTransform_union_value
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualPart(native_input):
+ return DafnyVirtualPart(
+ loc=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.loc.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ trans=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_VirtualTransform(
+ list_element
+ )
+ for list_element in native_input.trans
+ ]
+ )
+ )
+ )
+ if (native_input.trans is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_VirtualField(native_input):
+ return DafnyVirtualField(
+ name=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.name.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ parts=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_VirtualPart(
+ list_element
+ )
+ for list_element in native_input.parts
+ ]
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_BeaconVersion(native_input):
+ return DafnyBeaconVersion(
+ version=native_input.version,
+ keyStore=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_KeyStoreReference(
+ native_input.key_store
+ ),
+ keySource=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_BeaconKeySource(
+ native_input.key_source
+ ),
+ standardBeacons=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_StandardBeacon(
+ list_element
+ )
+ for list_element in native_input.standard_beacons
+ ]
+ ),
+ compoundBeacons=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_CompoundBeacon(
+ list_element
+ )
+ for list_element in native_input.compound_beacons
+ ]
+ )
+ )
+ )
+ if (native_input.compound_beacons is not None)
+ else (Option_None())
+ ),
+ virtualFields=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_VirtualField(
+ list_element
+ )
+ for list_element in native_input.virtual_fields
+ ]
+ )
+ )
+ )
+ if (native_input.virtual_fields is not None)
+ else (Option_None())
+ ),
+ encryptedParts=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_EncryptedPart(
+ list_element
+ )
+ for list_element in native_input.encrypted_parts
+ ]
+ )
+ )
+ )
+ if (native_input.encrypted_parts is not None)
+ else (Option_None())
+ ),
+ signedParts=(
+ (
+ Option_Some(
+ Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_SignedPart(
+ list_element
+ )
+ for list_element in native_input.signed_parts
+ ]
+ )
+ )
+ )
+ if (native_input.signed_parts is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbEncryptionConfig(native_input):
+ return DafnyDynamoDbEncryptionConfig()
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyDynamoDbEncryptorReference(
+ native_input,
+):
+ if hasattr(native_input, "_impl"):
+ return native_input._impl
+
+ else:
+ return native_input
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyPolicy(native_input):
+ if native_input == "FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT":
+ return LegacyPolicy_FORCE__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT()
+
+ elif native_input == "FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT":
+ return LegacyPolicy_FORBID__LEGACY__ENCRYPT__ALLOW__LEGACY__DECRYPT()
+
+ elif native_input == "FORBID_LEGACY_ENCRYPT_FORBID_LEGACY_DECRYPT":
+ return LegacyPolicy_FORBID__LEGACY__ENCRYPT__FORBID__LEGACY__DECRYPT()
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {native_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(native_input):
+ return DafnyLegacyOverride(
+ policy=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_LegacyPolicy(
+ native_input.policy
+ ),
+ encryptor=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_LegacyDynamoDbEncryptorReference(
+ native_input.encryptor
+ ),
+ attributeActionsOnEncrypt=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.attribute_actions_on_encrypt.items()
+ }
+ ),
+ defaultAttributeFlag=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ native_input.default_attribute_flag
+ )
+ )
+ )
+ if (native_input.default_attribute_flag is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(native_input):
+ if native_input == "FORCE_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ":
+ return PlaintextOverride_FORCE__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ()
+
+ elif native_input == "FORBID_PLAINTEXT_WRITE_ALLOW_PLAINTEXT_READ":
+ return PlaintextOverride_FORBID__PLAINTEXT__WRITE__ALLOW__PLAINTEXT__READ()
+
+ elif native_input == "FORBID_PLAINTEXT_WRITE_FORBID_PLAINTEXT_READ":
+ return PlaintextOverride_FORBID__PLAINTEXT__WRITE__FORBID__PLAINTEXT__READ()
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {native_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_SearchConfig(native_input):
+ return DafnySearchConfig(
+ versions=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_BeaconVersion(
+ list_element
+ )
+ for list_element in native_input.versions
+ ]
+ ),
+ writeVersion=native_input.write_version,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTableEncryptionConfig(
+ native_input,
+):
+ return DafnyDynamoDbTableEncryptionConfig(
+ logicalTableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.logical_table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ partitionKeyName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.partition_key_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ sortKeyName=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.sort_key_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.sort_key_name is not None)
+ else (Option_None())
+ ),
+ search=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_SearchConfig(
+ native_input.search
+ )
+ )
+ )
+ if (native_input.search is not None)
+ else (Option_None())
+ ),
+ attributeActionsOnEncrypt=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.attribute_actions_on_encrypt.items()
+ }
+ ),
+ allowedUnsignedAttributes=(
+ (
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input.allowed_unsigned_attributes
+ ]
+ )
+ )
+ )
+ if (native_input.allowed_unsigned_attributes is not None)
+ else (Option_None())
+ ),
+ allowedUnsignedAttributePrefix=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(
+ *[iter(native_input.allowed_unsigned_attribute_prefix.encode("utf-16-be"))] * 2
+ )
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.allowed_unsigned_attribute_prefix is not None)
+ else (Option_None())
+ ),
+ algorithmSuiteId=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ )
+ )
+ )
+ if (native_input.algorithm_suite_id is not None)
+ else (Option_None())
+ ),
+ keyring=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_KeyringReference(
+ native_input.keyring
+ )
+ )
+ )
+ if (
+ (native_input.keyring is not None)
+ and (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_KeyringReference(
+ native_input.keyring
+ )
+ is not None
+ )
+ )
+ else (Option_None())
+ ),
+ cmm=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ )
+ )
+ )
+ if (
+ (native_input.cmm is not None)
+ and (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ )
+ is not None
+ )
+ )
+ else (Option_None())
+ ),
+ legacyOverride=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(
+ native_input.legacy_override
+ )
+ )
+ )
+ if (native_input.legacy_override is not None)
+ else (Option_None())
+ ),
+ plaintextOverride=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(
+ native_input.plaintext_override
+ )
+ )
+ )
+ if (native_input.plaintext_override is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTablesEncryptionConfig(
+ native_input,
+):
+ return DafnyDynamoDbTablesEncryptionConfig(
+ tableEncryptionConfigs=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTableEncryptionConfig(
+ value
+ )
+ for (key, value) in native_input.table_encryption_configs.items()
+ }
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/aws_sdk_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/aws_sdk_to_dafny.py
new file mode 100644
index 000000000..c58eacb37
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/aws_sdk_to_dafny.py
@@ -0,0 +1,113 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+)
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+
+
+def com_amazonaws_dynamodb_AttributeValue(native_input):
+ if "S" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_S(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["S"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "N" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_N(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["N"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "B" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_B(Seq(native_input["B"]))
+ elif "SS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_SS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["SS"]
+ ]
+ )
+ )
+ elif "NS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["NS"]
+ ]
+ )
+ )
+ elif "BS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BS(Seq([Seq(list_element) for list_element in native_input["BS"]]))
+ elif "M" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_M(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["M"].items()
+ }
+ )
+ )
+ elif "L" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_L(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["L"]
+ ]
+ )
+ )
+ elif "NULL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NULL(native_input["NULL"])
+ elif "BOOL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BOOL(native_input["BOOL"])
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return AttributeValue_union_value
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/client.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/client.py
new file mode 100644
index 000000000..80b139bad
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/client.py
@@ -0,0 +1,335 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ IDynamoDbItemEncryptorClient,
+)
+from typing import Callable, TypeVar, cast
+
+from .config import Config, DynamoDbItemEncryptorConfig
+from .dafny_protocol import DafnyRequest, DafnyResponse
+from .plugin import set_config_impl
+from smithy_python.exceptions import SmithyRetryException
+from smithy_python.interfaces.interceptor import Interceptor, InterceptorContext
+from smithy_python.interfaces.retries import RetryErrorInfo, RetryErrorType
+
+from .config import Plugin
+from .deserialize import _deserialize_decrypt_item, _deserialize_encrypt_item
+from .errors import ServiceError
+from .models import (
+ DecryptItemInput,
+ DecryptItemOutput,
+ EncryptItemInput,
+ EncryptItemOutput,
+)
+from .serialize import _serialize_decrypt_item, _serialize_encrypt_item
+
+
+Input = TypeVar("Input")
+Output = TypeVar("Output")
+
+
+class DynamoDbItemEncryptor:
+ """Client for DynamoDbItemEncryptor.
+
+ :param config: Configuration for the client.
+ """
+
+ def __init__(
+ self,
+ config: DynamoDbItemEncryptorConfig | None = None,
+ dafny_client: IDynamoDbItemEncryptorClient | None = None,
+ ):
+ if config is None:
+ self._config = Config()
+ else:
+ self._config = config
+
+ client_plugins: list[Plugin] = [
+ set_config_impl,
+ ]
+
+ for plugin in client_plugins:
+ plugin(self._config)
+
+ if dafny_client is not None:
+ self._config.dafnyImplInterface.impl = dafny_client
+
+ def encrypt_item(self, input: EncryptItemInput) -> EncryptItemOutput:
+ """Encrypt a DynamoDB Item.
+
+ :param input: Inputs for encrypting a DynamoDB Item.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_encrypt_item,
+ deserialize=_deserialize_encrypt_item,
+ config=self._config,
+ operation_name="EncryptItem",
+ )
+
+ def decrypt_item(self, input: DecryptItemInput) -> DecryptItemOutput:
+ """Decrypt a DynamoDB Item.
+
+ :param input: Inputs for decrypting a DynamoDB Item.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_decrypt_item,
+ deserialize=_deserialize_decrypt_item,
+ config=self._config,
+ operation_name="DecryptItem",
+ )
+
+ def _execute_operation(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ try:
+ return self._handle_execution(input, plugins, serialize, deserialize, config, operation_name)
+ except Exception as e:
+ # Make sure every exception that we throw is an instance of ServiceError so
+ # customers can reliably catch everything we throw.
+ if not isinstance(e, ServiceError):
+ raise ServiceError(e) from e
+ raise e
+
+ def _handle_execution(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ context: InterceptorContext[Input, None, None, None] = InterceptorContext(
+ request=input,
+ response=None,
+ transport_request=None,
+ transport_response=None,
+ )
+ try:
+ _client_interceptors = config.interceptors
+ except AttributeError:
+ config.interceptors = []
+ _client_interceptors = config.interceptors
+ client_interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+ interceptors = client_interceptors
+
+ try:
+ # Step 1a: Invoke read_before_execution on client-level interceptors
+ for interceptor in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 1b: Run operation-level plugins
+ for plugin in plugins:
+ plugin(config)
+
+ _client_interceptors = config.interceptors
+ interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+
+ # Step 1c: Invoke the read_before_execution hooks on newly added
+ # interceptors.
+ for interceptor in interceptors:
+ if interceptor not in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 2: Invoke the modify_before_serialization hooks
+ for interceptor in interceptors:
+ context._request = interceptor.modify_before_serialization(context)
+
+ # Step 3: Invoke the read_before_serialization hooks
+ for interceptor in interceptors:
+ interceptor.read_before_serialization(context)
+
+ # Step 4: Serialize the request
+ context_with_transport_request = cast(InterceptorContext[Input, None, DafnyRequest, None], context)
+ context_with_transport_request._transport_request = serialize(
+ context_with_transport_request.request, config
+ )
+
+ # Step 5: Invoke read_after_serialization
+ for interceptor in interceptors:
+ interceptor.read_after_serialization(context_with_transport_request)
+
+ # Step 6: Invoke modify_before_retry_loop
+ for interceptor in interceptors:
+ context_with_transport_request._transport_request = interceptor.modify_before_retry_loop(
+ context_with_transport_request
+ )
+
+ # Step 7: Acquire the retry token.
+ retry_strategy = config.retry_strategy
+ retry_token = retry_strategy.acquire_initial_retry_token()
+
+ while True:
+ # Make an attempt, creating a copy of the context so we don't pass
+ # around old data.
+ context_with_response = self._handle_attempt(
+ deserialize,
+ interceptors,
+ context_with_transport_request.copy(),
+ config,
+ operation_name,
+ )
+
+ # We perform this type-ignored re-assignment because `context` needs
+ # to point at the latest context so it can be generically handled
+ # later on. This is only an issue here because we've created a copy,
+ # so we're no longer simply pointing at the same object in memory
+ # with different names and type hints. It is possible to address this
+ # without having to fall back to the type ignore, but it would impose
+ # unnecessary runtime costs.
+ context = context_with_response # type: ignore
+
+ if isinstance(context_with_response.response, Exception):
+ # Step 7u: Reacquire retry token if the attempt failed
+ try:
+ retry_token = retry_strategy.refresh_retry_token_for_retry(
+ token_to_renew=retry_token,
+ error_info=RetryErrorInfo(
+ # TODO: Determine the error type.
+ error_type=RetryErrorType.CLIENT_ERROR,
+ ),
+ )
+ except SmithyRetryException:
+ raise context_with_response.response
+ else:
+ # Step 8: Invoke record_success
+ retry_strategy.record_success(token=retry_token)
+ break
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request will have been definitively set, and
+ # The response will be set either with the modeled output or an exception. The
+ # transport_request and transport_response may be set or None.
+ execution_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_execution(interceptors, execution_context)
+
+ def _handle_attempt(
+ self,
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, None, DafnyRequest, None],
+ config: Config,
+ operation_name: str,
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ try:
+ # Step 7a: Invoke read_before_attempt
+ for interceptor in interceptors:
+ interceptor.read_before_attempt(context)
+
+ # Step 7m: Involve client Dafny impl
+ if config.dafnyImplInterface.impl is None:
+ raise Exception("No impl found on the operation config.")
+
+ context_with_response = cast(InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context)
+
+ context_with_response._transport_response = config.dafnyImplInterface.handle_request(
+ input=context_with_response.transport_request
+ )
+
+ # Step 7n: Invoke read_after_transmit
+ for interceptor in interceptors:
+ interceptor.read_after_transmit(context_with_response)
+
+ # Step 7o: Invoke modify_before_deserialization
+ for interceptor in interceptors:
+ context_with_response._transport_response = interceptor.modify_before_deserialization(
+ context_with_response
+ )
+
+ # Step 7p: Invoke read_before_deserialization
+ for interceptor in interceptors:
+ interceptor.read_before_deserialization(context_with_response)
+
+ # Step 7q: deserialize
+ context_with_output = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse],
+ context_with_response,
+ )
+ context_with_output._response = deserialize(context_with_output._transport_response, config)
+
+ # Step 7r: Invoke read_after_deserialization
+ for interceptor in interceptors:
+ interceptor.read_after_deserialization(context_with_output)
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request and transport_request have definitively been set,
+ # the response is either set or an exception, and the transport_resposne is either set or
+ # None. This will also be true after _finalize_attempt because there is no opportunity
+ # there to set the transport_response.
+ attempt_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_attempt(interceptors, attempt_context)
+
+ def _finalize_attempt(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ # Step 7s: Invoke modify_before_attempt_completion
+ try:
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_attempt_completion(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 7t: Invoke read_after_attempt
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_attempt(context)
+ except Exception as e:
+ context._response = e
+
+ return context
+
+ def _finalize_execution(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ ) -> Output:
+ try:
+ # Step 9: Invoke modify_before_completion
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_completion(context)
+
+ except Exception as e:
+ context._response = e
+
+ # Step 11: Invoke read_after_execution
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_execution(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 12: Return / throw
+ if isinstance(context.response, Exception):
+ raise context.response
+
+ # We may want to add some aspects of this context to the output types so we can
+ # return it to the end-users.
+ return context.response
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/config.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/config.py
new file mode 100644
index 000000000..4391e5b97
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/config.py
@@ -0,0 +1,310 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ DynamoDbItemEncryptorConfig_DynamoDbItemEncryptorConfig as DafnyDynamoDbItemEncryptorConfig,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional, TypeAlias
+
+from .dafnyImplInterface import DafnyImplInterface
+from smithy_python._private.retries import SimpleRetryStrategy
+from smithy_python.interfaces.retries import RetryStrategy
+
+from ..aws_cryptography_dbencryptionsdk_dynamodb.models import LegacyOverride
+
+
+_ServiceInterceptor = Any
+
+
+@dataclass(init=False)
+class Config:
+ """Configuration for DynamoDbItemEncryptor."""
+
+ interceptors: list[_ServiceInterceptor]
+ retry_strategy: RetryStrategy
+ dafnyImplInterface: DafnyImplInterface | None
+
+ def __init__(
+ self,
+ *,
+ interceptors: list[_ServiceInterceptor] | None = None,
+ retry_strategy: RetryStrategy | None = None,
+ dafnyImplInterface: DafnyImplInterface | None = None,
+ ):
+ """Constructor.
+
+ :param interceptors: The list of interceptors, which are hooks
+ that are called during the execution of a request.
+ :param retry_strategy: The retry strategy for issuing retry
+ tokens and computing retry delays.
+ :param dafnyImplInterface:
+ """
+ self.interceptors = interceptors or []
+ self.retry_strategy = retry_strategy or SimpleRetryStrategy()
+ self.dafnyImplInterface = dafnyImplInterface
+
+
+# A callable that allows customizing the config object on each request.
+Plugin: TypeAlias = Callable[[Config], None]
+
+
+class DynamoDbItemEncryptorConfig(Config):
+ logical_table_name: str
+ partition_key_name: str
+ sort_key_name: Optional[str]
+ attribute_actions_on_encrypt: dict[str, str]
+ allowed_unsigned_attributes: Optional[list[str]]
+ allowed_unsigned_attribute_prefix: Optional[str]
+ algorithm_suite_id: Optional[str]
+ keyring: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.Keyring"
+ ]
+ cmm: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ ]
+ legacy_override: Optional[LegacyOverride]
+ plaintext_override: Optional[str]
+
+ def __init__(
+ self,
+ *,
+ logical_table_name: str,
+ partition_key_name: str,
+ attribute_actions_on_encrypt: dict[str, str],
+ sort_key_name: Optional[str] = None,
+ allowed_unsigned_attributes: Optional[list[str]] = None,
+ allowed_unsigned_attribute_prefix: Optional[str] = None,
+ algorithm_suite_id: Optional[str] = None,
+ keyring: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.Keyring"
+ ] = None,
+ cmm: Optional[
+ "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ ] = None,
+ legacy_override: Optional[LegacyOverride] = None,
+ plaintext_override: Optional[str] = None,
+ ):
+ """The configuration for the client-side encryption of DynamoDB items.
+
+ :param logical_table_name: The logical table name for this
+ table. This is the name that is cryptographically bound with
+ your data. This can be the same as the actual DynamoDB table
+ name. It's purpose is to be distinct from the DynamoDB table
+ name so that the data may still be authenticated if being
+ read from different (but logically similar) tables, such as
+ a backup table.
+ :param partition_key_name: The name of the partition key on the
+ table this item will be written to or was read from.
+ :param attribute_actions_on_encrypt: A map that describes what
+ attributes should be encrypted and/or signed on encrypt.
+ This map must contain all attributes that might be
+ encountered during encryption.
+ :param sort_key_name: If this table contains a sort key, the
+ name of the sort key on the table this item will be written
+ to or was read from.
+ :param allowed_unsigned_attributes: A list of attribute names
+ such that, if encountered during decryption, those
+ attributes are treated as unsigned.
+ :param allowed_unsigned_attribute_prefix: A prefix such that, if
+ during decryption any attribute has a name with this prefix,
+ it is treated as unsigned.
+ :param algorithm_suite_id: An ID for the algorithm suite to use
+ during encryption and decryption.
+ :param keyring: The Keyring that should be used to wrap and
+ unwrap data keys. If specified a Default Cryptographic
+ Materials Manager with this Keyring is used to obtain
+ materials for encryption and decryption. Either a Keyring or
+ a Cryptographic Materials Manager must be specified.
+ :param cmm: The Cryptographic Materials Manager that is used to
+ obtain materials for encryption and decryption. Either a
+ Keyring or a Cryptographic Materials Manager must be
+ specified.
+ :param legacy_override: A configuration that override encryption
+ and/or decryption to instead perform legacy encryption
+ and/or decryption. Used as part of migration from version
+ 2.x to version 3.x.
+ :param plaintext_override: A configuration that override
+ encryption and/or decryption to instead passthrough and
+ write and/or read plaintext. Used to update plaintext tables
+ to fully use client-side encryption.
+ """
+ super().__init__()
+ self.logical_table_name = logical_table_name
+ if (partition_key_name is not None) and (len(partition_key_name) < 1):
+ raise ValueError("The size of partition_key_name must be greater than or equal to 1")
+
+ if (partition_key_name is not None) and (len(partition_key_name) > 255):
+ raise ValueError("The size of partition_key_name must be less than or equal to 255")
+
+ self.partition_key_name = partition_key_name
+ self.attribute_actions_on_encrypt = attribute_actions_on_encrypt
+ if (sort_key_name is not None) and (len(sort_key_name) < 1):
+ raise ValueError("The size of sort_key_name must be greater than or equal to 1")
+
+ if (sort_key_name is not None) and (len(sort_key_name) > 255):
+ raise ValueError("The size of sort_key_name must be less than or equal to 255")
+
+ self.sort_key_name = sort_key_name
+ if (allowed_unsigned_attributes is not None) and (len(allowed_unsigned_attributes) < 1):
+ raise ValueError("The size of allowed_unsigned_attributes must be greater than or equal to 1")
+
+ self.allowed_unsigned_attributes = allowed_unsigned_attributes
+ self.allowed_unsigned_attribute_prefix = allowed_unsigned_attribute_prefix
+ self.algorithm_suite_id = algorithm_suite_id
+ self.keyring = keyring
+ self.cmm = cmm
+ self.legacy_override = legacy_override
+ self.plaintext_override = plaintext_override
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbItemEncryptorConfig to a dictionary."""
+ d: Dict[str, Any] = {
+ "logical_table_name": self.logical_table_name,
+ "partition_key_name": self.partition_key_name,
+ "attribute_actions_on_encrypt": self.attribute_actions_on_encrypt,
+ }
+
+ if self.sort_key_name is not None:
+ d["sort_key_name"] = self.sort_key_name
+
+ if self.allowed_unsigned_attributes is not None:
+ d["allowed_unsigned_attributes"] = self.allowed_unsigned_attributes
+
+ if self.allowed_unsigned_attribute_prefix is not None:
+ d["allowed_unsigned_attribute_prefix"] = self.allowed_unsigned_attribute_prefix
+
+ if self.algorithm_suite_id is not None:
+ d["algorithm_suite_id"] = self.algorithm_suite_id
+
+ if self.keyring is not None:
+ d["keyring"] = self.keyring.as_dict()
+
+ if self.cmm is not None:
+ d["cmm"] = self.cmm.as_dict()
+
+ if self.legacy_override is not None:
+ d["legacy_override"] = self.legacy_override.as_dict()
+
+ if self.plaintext_override is not None:
+ d["plaintext_override"] = self.plaintext_override
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbItemEncryptorConfig":
+ """Creates a DynamoDbItemEncryptorConfig from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ Keyring,
+ )
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "logical_table_name": d["logical_table_name"],
+ "partition_key_name": d["partition_key_name"],
+ "attribute_actions_on_encrypt": d["attribute_actions_on_encrypt"],
+ }
+
+ if "sort_key_name" in d:
+ kwargs["sort_key_name"] = d["sort_key_name"]
+
+ if "allowed_unsigned_attributes" in d:
+ kwargs["allowed_unsigned_attributes"] = d["allowed_unsigned_attributes"]
+
+ if "allowed_unsigned_attribute_prefix" in d:
+ kwargs["allowed_unsigned_attribute_prefix"] = d["allowed_unsigned_attribute_prefix"]
+
+ if "algorithm_suite_id" in d:
+ kwargs["algorithm_suite_id"] = d["algorithm_suite_id"]
+
+ if "keyring" in d:
+ kwargs["keyring"] = Keyring.from_dict(d["keyring"])
+
+ if "cmm" in d:
+ kwargs["cmm"] = CryptographicMaterialsManager.from_dict(d["cmm"])
+
+ if "legacy_override" in d:
+ kwargs["legacy_override"] = LegacyOverride.from_dict(d["legacy_override"])
+
+ if "plaintext_override" in d:
+ kwargs["plaintext_override"] = d["plaintext_override"]
+
+ return DynamoDbItemEncryptorConfig(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbItemEncryptorConfig("
+ if self.logical_table_name is not None:
+ result += f"logical_table_name={repr(self.logical_table_name)}, "
+
+ if self.partition_key_name is not None:
+ result += f"partition_key_name={repr(self.partition_key_name)}, "
+
+ if self.sort_key_name is not None:
+ result += f"sort_key_name={repr(self.sort_key_name)}, "
+
+ if self.attribute_actions_on_encrypt is not None:
+ result += f"attribute_actions_on_encrypt={repr(self.attribute_actions_on_encrypt)}, "
+
+ if self.allowed_unsigned_attributes is not None:
+ result += f"allowed_unsigned_attributes={repr(self.allowed_unsigned_attributes)}, "
+
+ if self.allowed_unsigned_attribute_prefix is not None:
+ result += f"allowed_unsigned_attribute_prefix={repr(self.allowed_unsigned_attribute_prefix)}, "
+
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.keyring is not None:
+ result += f"keyring={repr(self.keyring)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.legacy_override is not None:
+ result += f"legacy_override={repr(self.legacy_override)}, "
+
+ if self.plaintext_override is not None:
+ result += f"plaintext_override={repr(self.plaintext_override)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbItemEncryptorConfig):
+ return False
+ attributes: list[str] = [
+ "logical_table_name",
+ "partition_key_name",
+ "sort_key_name",
+ "attribute_actions_on_encrypt",
+ "allowed_unsigned_attributes",
+ "allowed_unsigned_attribute_prefix",
+ "algorithm_suite_id",
+ "keyring",
+ "cmm",
+ "legacy_override",
+ "plaintext_override",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def dafny_config_to_smithy_config(dafny_config) -> DynamoDbItemEncryptorConfig:
+ """Converts the provided Dafny shape for this localService's config into
+ the corresponding Smithy-modelled shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DynamoDbItemEncryptorConfig(
+ dafny_config
+ )
+
+
+def smithy_config_to_dafny_config(smithy_config) -> DafnyDynamoDbItemEncryptorConfig:
+ """Converts the provided Smithy-modelled shape for this localService's
+ config into the corresponding Dafny shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DynamoDbItemEncryptorConfig(
+ smithy_config
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafnyImplInterface.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafnyImplInterface.py
new file mode 100644
index 000000000..06ead47b7
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafnyImplInterface.py
@@ -0,0 +1,34 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbItemEncryptor import (
+ DynamoDbItemEncryptorClient,
+)
+from .dafny_protocol import DafnyRequest
+
+
+class DafnyImplInterface:
+ impl: DynamoDbItemEncryptorClient | None = None
+
+ # operation_map cannot be created at dafnyImplInterface create time,
+ # as the map's values reference values inside `self.impl`,
+ # and impl is only populated at runtime.
+ # Accessing these before impl is populated results in an error.
+ # At runtime, the map is populated once and cached.
+ operation_map = None
+
+ def handle_request(self, input: DafnyRequest):
+ if self.operation_map is None:
+ self.operation_map = {
+ "EncryptItem": self.impl.EncryptItem,
+ "DecryptItem": self.impl.DecryptItem,
+ }
+
+ # This logic is where a typical Smithy client would expect the "server" to be.
+ # This code can be thought of as logic our Dafny "server" uses
+ # to route incoming client requests to the correct request handler code.
+ if input.dafny_operation_input is None:
+ return self.operation_map[input.operation_name]()
+ else:
+ return self.operation_map[input.operation_name](input.dafny_operation_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_protocol.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_protocol.py
new file mode 100644
index 000000000..bb2adb9a8
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_protocol.py
@@ -0,0 +1,33 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ DecryptItemInput_DecryptItemInput as DafnyDecryptItemInput,
+ EncryptItemInput_EncryptItemInput as DafnyEncryptItemInput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+from typing import Union
+
+
+class DafnyRequest:
+ operation_name: str
+
+ # dafny_operation_input can take on any one of the types
+ # of the input values passed to the Dafny implementation
+ dafny_operation_input: Union[
+ DafnyEncryptItemInput,
+ DafnyDecryptItemInput,
+ ]
+
+ def __init__(self, operation_name, dafny_operation_input):
+ self.operation_name = operation_name
+ self.dafny_operation_input = dafny_operation_input
+
+
+class DafnyResponse(Wrappers.Result):
+ def __init__(self):
+ super().__init__(self)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_aws_sdk.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_aws_sdk.py
new file mode 100644
index 000000000..9aca0964e
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_aws_sdk.py
@@ -0,0 +1,75 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+)
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+
+
+def com_amazonaws_dynamodb_AttributeValue(dafny_input):
+ # Convert AttributeValue
+ if isinstance(dafny_input, AttributeValue_S):
+ AttributeValue_union_value = {
+ "S": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.S).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_N):
+ AttributeValue_union_value = {
+ "N": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.N).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_B):
+ AttributeValue_union_value = {"B": bytes(dafny_input.B)}
+ elif isinstance(dafny_input, AttributeValue_SS):
+ AttributeValue_union_value = {
+ "SS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.SS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NS):
+ AttributeValue_union_value = {
+ "NS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.NS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_BS):
+ AttributeValue_union_value = {"BS": [bytes(list_element) for list_element in dafny_input.BS]}
+ elif isinstance(dafny_input, AttributeValue_M):
+ AttributeValue_union_value = {
+ "M": {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.M.items
+ }
+ }
+ elif isinstance(dafny_input, AttributeValue_L):
+ AttributeValue_union_value = {
+ "L": [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.L
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NULL):
+ AttributeValue_union_value = {"NULL": dafny_input.NULL}
+ elif isinstance(dafny_input, AttributeValue_BOOL):
+ AttributeValue_union_value = {"BOOL": dafny_input.BOOL}
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return AttributeValue_union_value
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_smithy.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_smithy.py
new file mode 100644
index 000000000..9922ce15d
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/dafny_to_smithy.py
@@ -0,0 +1,239 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.EncryptItemInput(
+ plaintext_item={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.plaintextItem.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.DecryptItemInput(
+ encrypted_item={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.encryptedItem.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.ParsedHeader(
+ attribute_actions_on_encrypt={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.attributeActionsOnEncrypt.items
+ },
+ algorithm_suite_id=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId
+ ),
+ encrypted_data_keys=[
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_EncryptedDataKey(
+ list_element
+ )
+ for list_element in dafny_input.encryptedDataKeys
+ ],
+ stored_encryption_context={
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.storedEncryptionContext.items
+ },
+ encryption_context={
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.items
+ },
+ selector_context={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.selectorContext.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.EncryptItemOutput(
+ encrypted_item={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.encryptedItem.items
+ },
+ parsed_header=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(
+ dafny_input.parsedHeader.value
+ )
+ )
+ if (dafny_input.parsedHeader.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.DecryptItemOutput(
+ plaintext_item={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.plaintextItem.items
+ },
+ parsed_header=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(
+ dafny_input.parsedHeader.value
+ )
+ )
+ if (dafny_input.parsedHeader.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_AtomicPrimitivesReference(
+ dafny_input,
+):
+ from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.client import (
+ AwsCryptographicPrimitives,
+ )
+
+ return AwsCryptographicPrimitives(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DynamoDbItemEncryptorConfig(
+ dafny_input,
+):
+ # Deferred import of .config to avoid circular dependency
+ import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.config
+
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.config.DynamoDbItemEncryptorConfig(
+ logical_table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.logicalTableName).decode(
+ "utf-16-be"
+ ),
+ partition_key_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.partitionKeyName).decode(
+ "utf-16-be"
+ ),
+ sort_key_name=(
+ (b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.sortKeyName.value).decode("utf-16-be"))
+ if (dafny_input.sortKeyName.is_Some)
+ else None
+ ),
+ attribute_actions_on_encrypt={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.attributeActionsOnEncrypt.items
+ },
+ allowed_unsigned_attributes=(
+ (
+ [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.allowedUnsignedAttributes.value
+ ]
+ )
+ if (dafny_input.allowedUnsignedAttributes.is_Some)
+ else None
+ ),
+ allowed_unsigned_attribute_prefix=(
+ (
+ b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.allowedUnsignedAttributePrefix.value).decode(
+ "utf-16-be"
+ )
+ )
+ if (dafny_input.allowedUnsignedAttributePrefix.is_Some)
+ else None
+ ),
+ algorithm_suite_id=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId.value
+ )
+ )
+ if (dafny_input.algorithmSuiteId.is_Some)
+ else None
+ ),
+ keyring=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_KeyringReference(
+ dafny_input.keyring.UnwrapOr(None)
+ )
+ )
+ if (dafny_input.keyring.UnwrapOr(None) is not None)
+ else None
+ ),
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm.UnwrapOr(None)
+ )
+ )
+ if (dafny_input.cmm.UnwrapOr(None) is not None)
+ else None
+ ),
+ legacy_override=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(
+ dafny_input.legacyOverride.value
+ )
+ )
+ if (dafny_input.legacyOverride.is_Some)
+ else None
+ ),
+ plaintext_override=(
+ (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(
+ dafny_input.plaintextOverride.value
+ )
+ )
+ if (dafny_input.plaintextOverride.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_StructuredEncryptionReference(
+ dafny_input,
+):
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.client import (
+ StructuredEncryption,
+ )
+
+ return StructuredEncryption(config=None, dafny_client=dafny_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/deserialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/deserialize.py
new file mode 100644
index 000000000..fb27cecff
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/deserialize.py
@@ -0,0 +1,98 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ DecryptItemOutput_DecryptItemOutput as DafnyDecryptItemOutput,
+ EncryptItemOutput_EncryptItemOutput as DafnyEncryptItemOutput,
+ Error,
+ Error_DynamoDbItemEncryptorException,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy
+from typing import Any
+
+from .dafny_protocol import DafnyResponse
+from .errors import (
+ AwsCryptographicMaterialProviders,
+ AwsCryptographicPrimitives,
+ CollectionOfErrors,
+ ComAmazonawsDynamodb,
+ DynamoDbEncryption,
+ DynamoDbItemEncryptorException,
+ OpaqueError,
+ ServiceError,
+ StructuredEncryption,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.deserialize import (
+ _deserialize_error as aws_cryptography_materialproviders_deserialize_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.deserialize import (
+ _deserialize_error as aws_cryptography_primitives_deserialize_error,
+)
+
+from ..aws_cryptography_dbencryptionsdk_dynamodb.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error,
+)
+from ..aws_cryptography_dbencryptionsdk_structuredencryption.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error,
+)
+from .config import Config
+
+
+def _deserialize_encrypt_item(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemOutput(
+ input.value
+ )
+
+
+def _deserialize_decrypt_item(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemOutput(
+ input.value
+ )
+
+
+def _deserialize_error(error: Error) -> ServiceError:
+ if error.is_Opaque:
+ return OpaqueError(obj=error.obj)
+ elif error.is_OpaqueWithText:
+ return OpaqueErrorWithText(obj=error.obj, obj_message=error.objMessage)
+ elif error.is_CollectionOfErrors:
+ return CollectionOfErrors(
+ message=_dafny.string_of(error.message),
+ list=[_deserialize_error(dafny_e) for dafny_e in error.list],
+ )
+ elif error.is_DynamoDbItemEncryptorException:
+ return DynamoDbItemEncryptorException(message=_dafny.string_of(error.message))
+ elif error.is_AwsCryptographyDbEncryptionSdkStructuredEncryption:
+ return StructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error(
+ error.AwsCryptographyDbEncryptionSdkStructuredEncryption
+ )
+ )
+ elif error.is_AwsCryptographyPrimitives:
+ return AwsCryptographicPrimitives(
+ aws_cryptography_primitives_deserialize_error(error.AwsCryptographyPrimitives)
+ )
+ elif error.is_AwsCryptographyDbEncryptionSdkDynamoDb:
+ return DynamoDbEncryption(
+ aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error(error.AwsCryptographyDbEncryptionSdkDynamoDb)
+ )
+ elif error.is_AwsCryptographyMaterialProviders:
+ return AwsCryptographicMaterialProviders(
+ aws_cryptography_materialproviders_deserialize_error(error.AwsCryptographyMaterialProviders)
+ )
+ elif error.is_ComAmazonawsDynamodb:
+ return ComAmazonawsDynamodb(message=_dafny.string_of(error.ComAmazonawsDynamodb.message))
+ else:
+ return OpaqueError(obj=error)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/errors.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/errors.py
new file mode 100644
index 000000000..207a1df12
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/errors.py
@@ -0,0 +1,335 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_materialproviders_smithy_error_to_dafny_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_primitives_smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_dynamodb_smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.errors
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error,
+)
+from typing import Any, Dict, Generic, List, Literal, TypeVar
+
+
+class ServiceError(Exception):
+ """Base error for all errors in the service."""
+
+ pass
+
+
+T = TypeVar("T")
+
+
+class ApiError(ServiceError, Generic[T]):
+ """Base error for all api errors in the service."""
+
+ code: T
+
+ def __init__(self, message: str):
+ super().__init__(message)
+ self.message = message
+
+
+class UnknownApiError(ApiError[Literal["Unknown"]]):
+ """Error representing any unknown api errors."""
+
+ code: Literal["Unknown"] = "Unknown"
+
+
+class DynamoDbItemEncryptorException(ApiError[Literal["DynamoDbItemEncryptorException"]]):
+ code: Literal["DynamoDbItemEncryptorException"] = "DynamoDbItemEncryptorException"
+ message: str
+
+ def __init__(
+ self,
+ *,
+ message: str,
+ ):
+ super().__init__(message)
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbItemEncryptorException to a dictionary."""
+ return {
+ "message": self.message,
+ "code": self.code,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbItemEncryptorException":
+ """Creates a DynamoDbItemEncryptorException from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ }
+
+ return DynamoDbItemEncryptorException(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbItemEncryptorException("
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbItemEncryptorException):
+ return False
+ attributes: list[str] = [
+ "message",
+ "message",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DynamoDbItemEncryptorException(ApiError[Literal["DynamoDbItemEncryptorException"]]):
+ code: Literal["DynamoDbItemEncryptorException"] = "DynamoDbItemEncryptorException"
+ message: str
+
+
+class AwsCryptographicPrimitives(ApiError[Literal["AwsCryptographicPrimitives"]]):
+ AwsCryptographicPrimitives: Any
+
+
+class ComAmazonawsDynamodb(ApiError[Literal["ComAmazonawsDynamodb"]]):
+ ComAmazonawsDynamodb: Any
+
+
+class AwsCryptographicMaterialProviders(ApiError[Literal["AwsCryptographicMaterialProviders"]]):
+ AwsCryptographicMaterialProviders: Any
+
+
+class StructuredEncryption(ApiError[Literal["StructuredEncryption"]]):
+ StructuredEncryption: Any
+
+
+class DynamoDbEncryption(ApiError[Literal["DynamoDbEncryption"]]):
+ DynamoDbEncryption: Any
+
+
+class CollectionOfErrors(ApiError[Literal["CollectionOfErrors"]]):
+ code: Literal["CollectionOfErrors"] = "CollectionOfErrors"
+ message: str
+ list: List[ServiceError]
+
+ def __init__(self, *, message: str, list):
+ super().__init__(message)
+ self.list = list
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CollectionOfErrors to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "list": self.list,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CollectionOfErrors":
+ """Creates a CollectionOfErrors from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "list": d["list"]}
+
+ return CollectionOfErrors(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CollectionOfErrors("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"list={self.list}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CollectionOfErrors):
+ return False
+ if not (self.list == other.list):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueError(ApiError[Literal["OpaqueError"]]):
+ code: Literal["OpaqueError"] = "OpaqueError"
+ obj: Any # As an OpaqueError, type of obj is unknown
+
+ def __init__(self, *, obj):
+ super().__init__("")
+ self.obj = obj
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueError":
+ """Creates a OpaqueError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "obj": d["obj"]}
+
+ return OpaqueError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueWithTextError(ApiError[Literal["OpaqueWithTextError"]]):
+ code: Literal["OpaqueWithTextError"] = "OpaqueWithTextError"
+ obj: Any # As an OpaqueWithTextError, type of obj is unknown
+ obj_message: str # obj_message is a message representing the details of obj
+
+ def __init__(self, *, obj, obj_message):
+ super().__init__("")
+ self.obj = obj
+ self.obj_message = obj_message
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueWithTextError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ "obj_message": self.obj_message,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueWithTextError":
+ """Creates a OpaqueWithTextError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ "obj": d["obj"],
+ "obj_message": d["obj_message"],
+ }
+
+ return OpaqueWithTextError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueWithTextError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += f"obj_message={self.obj_message}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueWithTextError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _smithy_error_to_dafny_error(e: ServiceError):
+ """Converts the provided native Smithy-modeled error into the corresponding
+ Dafny error."""
+ if isinstance(
+ e,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.errors.DynamoDbItemEncryptorException,
+ ):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_DynamoDbItemEncryptorException(
+ message=_dafny.Seq(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicPrimitives):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_AwsCryptographyPrimitives(
+ aws_cryptography_primitives_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, ComAmazonawsDynamodb):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_ComAmazonawsDynamodb(
+ com_amazonaws_dynamodb_sdk_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicMaterialProviders):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_AwsCryptographyMaterialProviders(
+ aws_cryptography_materialproviders_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, StructuredEncryption):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_AwsCryptographyDbEncryptionSdkStructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, DynamoDbEncryption):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_AwsCryptographyDbEncryptionSdkDynamoDb(
+ aws_cryptography_dbencryptionsdk_dynamodb_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, CollectionOfErrors):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_CollectionOfErrors(
+ message=_dafny.Seq(e.message),
+ list=_dafny.Seq(_smithy_error_to_dafny_error(native_err) for native_err in e.list),
+ )
+
+ if isinstance(e, OpaqueError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_Opaque(
+ obj=e.obj
+ )
+
+ if isinstance(e, OpaqueWithTextError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_OpaqueWithText(
+ obj=e.obj, objMessage=e.obj_message
+ )
+
+ else:
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.Error_Opaque(
+ obj=e
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/models.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/models.py
new file mode 100644
index 000000000..96f5b86d3
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/models.py
@@ -0,0 +1,329 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from typing import Any, Dict, Optional
+
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.models import (
+ EncryptedDataKey,
+)
+
+
+class DecryptItemInput:
+ encrypted_item: "dict[str, dict[str, Any]]"
+
+ def __init__(
+ self,
+ *,
+ encrypted_item: "dict[str, dict[str, Any]]",
+ ):
+ """Inputs for decrypting a DynamoDB Item.
+
+ :param encrypted_item: The encrypted DynamoDB item to decrypt.
+ """
+ self.encrypted_item = encrypted_item
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptItemInput to a dictionary."""
+ return {
+ "encrypted_item": self.encrypted_item,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptItemInput":
+ """Creates a DecryptItemInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "encrypted_item": d["encrypted_item"],
+ }
+
+ return DecryptItemInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptItemInput("
+ if self.encrypted_item is not None:
+ result += f"encrypted_item={repr(self.encrypted_item)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptItemInput):
+ return False
+ attributes: list[str] = [
+ "encrypted_item",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptItemInput:
+ plaintext_item: "dict[str, dict[str, Any]]"
+
+ def __init__(
+ self,
+ *,
+ plaintext_item: "dict[str, dict[str, Any]]",
+ ):
+ """Inputs for encrypting a DynamoDB Item.
+
+ :param plaintext_item: The DynamoDB item to encrypt.
+ """
+ self.plaintext_item = plaintext_item
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptItemInput to a dictionary."""
+ return {
+ "plaintext_item": self.plaintext_item,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptItemInput":
+ """Creates a EncryptItemInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "plaintext_item": d["plaintext_item"],
+ }
+
+ return EncryptItemInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptItemInput("
+ if self.plaintext_item is not None:
+ result += f"plaintext_item={repr(self.plaintext_item)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptItemInput):
+ return False
+ attributes: list[str] = [
+ "plaintext_item",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ParsedHeader:
+ attribute_actions_on_encrypt: dict[str, str]
+ algorithm_suite_id: str
+ encrypted_data_keys: list[EncryptedDataKey]
+ stored_encryption_context: dict[str, str]
+ encryption_context: dict[str, str]
+ selector_context: "dict[str, dict[str, Any]]"
+
+ def __init__(
+ self,
+ *,
+ attribute_actions_on_encrypt: dict[str, str],
+ algorithm_suite_id: str,
+ encrypted_data_keys: list[EncryptedDataKey],
+ stored_encryption_context: dict[str, str],
+ encryption_context: dict[str, str],
+ selector_context: "dict[str, dict[str, Any]]",
+ ):
+ """A parsed version of the header that was written with or read on an
+ encrypted DynamoDB item.
+
+ :param attribute_actions_on_encrypt: The non-DO_NOTHING Crypto
+ Actions that were configured when this item was originally
+ encrypted.
+ :param algorithm_suite_id: The ID of the algorithm suite that
+ was used to encrypt this item.
+ :param encrypted_data_keys: The encrypted data keys that are
+ stored in the header of this item.
+ :param stored_encryption_context: The portion of the encryption
+ context that was stored in the header of this item.
+ :param encryption_context: The full encryption context.
+ :param selector_context: The encryption context as presented to
+ the branch key selector.
+ """
+ self.attribute_actions_on_encrypt = attribute_actions_on_encrypt
+ self.algorithm_suite_id = algorithm_suite_id
+ self.encrypted_data_keys = encrypted_data_keys
+ self.stored_encryption_context = stored_encryption_context
+ self.encryption_context = encryption_context
+ self.selector_context = selector_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ParsedHeader to a dictionary."""
+ return {
+ "attribute_actions_on_encrypt": self.attribute_actions_on_encrypt,
+ "algorithm_suite_id": self.algorithm_suite_id,
+ "encrypted_data_keys": self.encrypted_data_keys,
+ "stored_encryption_context": self.stored_encryption_context,
+ "encryption_context": self.encryption_context,
+ "selector_context": self.selector_context,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ParsedHeader":
+ """Creates a ParsedHeader from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "attribute_actions_on_encrypt": d["attribute_actions_on_encrypt"],
+ "algorithm_suite_id": d["algorithm_suite_id"],
+ "encrypted_data_keys": d["encrypted_data_keys"],
+ "stored_encryption_context": d["stored_encryption_context"],
+ "encryption_context": d["encryption_context"],
+ "selector_context": d["selector_context"],
+ }
+
+ return ParsedHeader(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ParsedHeader("
+ if self.attribute_actions_on_encrypt is not None:
+ result += f"attribute_actions_on_encrypt={repr(self.attribute_actions_on_encrypt)}, "
+
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.encrypted_data_keys is not None:
+ result += f"encrypted_data_keys={repr(self.encrypted_data_keys)}, "
+
+ if self.stored_encryption_context is not None:
+ result += f"stored_encryption_context={repr(self.stored_encryption_context)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}, "
+
+ if self.selector_context is not None:
+ result += f"selector_context={repr(self.selector_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ParsedHeader):
+ return False
+ attributes: list[str] = [
+ "attribute_actions_on_encrypt",
+ "algorithm_suite_id",
+ "encrypted_data_keys",
+ "stored_encryption_context",
+ "encryption_context",
+ "selector_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DecryptItemOutput:
+ plaintext_item: "dict[str, dict[str, Any]]"
+ parsed_header: Optional["ParsedHeader"]
+
+ def __init__(
+ self,
+ *,
+ plaintext_item: "dict[str, dict[str, Any]]",
+ parsed_header: Optional["ParsedHeader"] = None,
+ ):
+ """Outputs for decrypting a DynamoDB Item.
+
+ :param plaintext_item: The decrypted DynamoDB item.
+ :param parsed_header: A parsed version of the header on the
+ encrypted DynamoDB item.
+ """
+ self.plaintext_item = plaintext_item
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptItemOutput to a dictionary."""
+ d: Dict[str, Any] = {
+ "plaintext_item": self.plaintext_item,
+ }
+
+ if self.parsed_header is not None:
+ d["parsed_header"] = self.parsed_header.as_dict()
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptItemOutput":
+ """Creates a DecryptItemOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "plaintext_item": d["plaintext_item"],
+ }
+
+ if "parsed_header" in d:
+ kwargs["parsed_header"] = ParsedHeader.from_dict(d["parsed_header"])
+
+ return DecryptItemOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptItemOutput("
+ if self.plaintext_item is not None:
+ result += f"plaintext_item={repr(self.plaintext_item)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptItemOutput):
+ return False
+ attributes: list[str] = [
+ "plaintext_item",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptItemOutput:
+ encrypted_item: "dict[str, dict[str, Any]]"
+ parsed_header: Optional["ParsedHeader"]
+
+ def __init__(
+ self,
+ *,
+ encrypted_item: "dict[str, dict[str, Any]]",
+ parsed_header: Optional["ParsedHeader"] = None,
+ ):
+ """Outputs for encrypting a DynamoDB Item.
+
+ :param encrypted_item: The encrypted DynamoDB item.
+ :param parsed_header: A parsed version of the header written
+ with the encrypted DynamoDB item.
+ """
+ self.encrypted_item = encrypted_item
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptItemOutput to a dictionary."""
+ d: Dict[str, Any] = {
+ "encrypted_item": self.encrypted_item,
+ }
+
+ if self.parsed_header is not None:
+ d["parsed_header"] = self.parsed_header.as_dict()
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptItemOutput":
+ """Creates a EncryptItemOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "encrypted_item": d["encrypted_item"],
+ }
+
+ if "parsed_header" in d:
+ kwargs["parsed_header"] = ParsedHeader.from_dict(d["parsed_header"])
+
+ return EncryptItemOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptItemOutput("
+ if self.encrypted_item is not None:
+ result += f"encrypted_item={repr(self.encrypted_item)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptItemOutput):
+ return False
+ attributes: list[str] = [
+ "encrypted_item",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Unit:
+ pass
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/plugin.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/plugin.py
new file mode 100644
index 000000000..35a252355
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/plugin.py
@@ -0,0 +1,49 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from .config import (
+ Config,
+ Plugin,
+ smithy_config_to_dafny_config,
+ DynamoDbItemEncryptorConfig,
+)
+from smithy_python.interfaces.retries import RetryStrategy
+from smithy_python.exceptions import SmithyRetryException
+from .dafnyImplInterface import DafnyImplInterface
+
+
+def set_config_impl(config: Config):
+ """Set the Dafny-compiled implementation in the Smithy-Python client Config
+ and load our custom NoRetriesStrategy."""
+ config.dafnyImplInterface = DafnyImplInterface()
+ if isinstance(config, DynamoDbItemEncryptorConfig):
+ from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbItemEncryptor import (
+ default__,
+ )
+
+ config.dafnyImplInterface.impl = default__.DynamoDbItemEncryptor(smithy_config_to_dafny_config(config)).value
+ config.retry_strategy = NoRetriesStrategy()
+
+
+class ZeroRetryDelayToken:
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not wait to retry.
+ """
+
+ retry_delay = 0
+
+
+class NoRetriesStrategy(RetryStrategy):
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not retry calling Dafny code.
+ """
+
+ def acquire_initial_retry_token(self):
+ return ZeroRetryDelayToken()
+
+ def refresh_retry_token_for_retry(self, token_to_renew, error_info):
+ # Do not retry
+ raise SmithyRetryException()
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/serialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/serialize.py
new file mode 100644
index 000000000..8764734dd
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/serialize.py
@@ -0,0 +1,27 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny
+
+from .dafny_protocol import DafnyRequest
+
+from .config import Config
+
+
+def _serialize_encrypt_item(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="EncryptItem",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemInput(
+ input
+ ),
+ )
+
+
+def _serialize_decrypt_item(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="DecryptItem",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemInput(
+ input
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/smithy_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/smithy_to_dafny.py
new file mode 100644
index 000000000..215ceeff3
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/smithy_to_dafny.py
@@ -0,0 +1,332 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ DecryptItemInput_DecryptItemInput as DafnyDecryptItemInput,
+ DecryptItemOutput_DecryptItemOutput as DafnyDecryptItemOutput,
+ DynamoDbItemEncryptorConfig_DynamoDbItemEncryptorConfig as DafnyDynamoDbItemEncryptorConfig,
+ EncryptItemInput_EncryptItemInput as DafnyEncryptItemInput,
+ EncryptItemOutput_EncryptItemOutput as DafnyEncryptItemOutput,
+ ParsedHeader_ParsedHeader as DafnyParsedHeader,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny
+from smithy_dafny_standard_library.internaldafny.generated.Wrappers import (
+ Option_None,
+ Option_Some,
+)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemInput(
+ native_input,
+):
+ return DafnyEncryptItemInput(
+ plaintextItem=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.plaintext_item.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemInput(
+ native_input,
+):
+ return DafnyDecryptItemInput(
+ encryptedItem=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.encrypted_item.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemOutput(
+ native_input,
+):
+ return DafnyEncryptItemOutput(
+ encryptedItem=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.encrypted_item.items()
+ }
+ ),
+ parsedHeader=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(
+ native_input.parsed_header
+ )
+ )
+ )
+ if (native_input.parsed_header is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(native_input):
+ return DafnyParsedHeader(
+ attributeActionsOnEncrypt=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.attribute_actions_on_encrypt.items()
+ }
+ ),
+ algorithmSuiteId=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ ),
+ encryptedDataKeys=Seq(
+ [
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_EncryptedDataKey(
+ list_element
+ )
+ for list_element in native_input.encrypted_data_keys
+ ]
+ ),
+ storedEncryptionContext=Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.stored_encryption_context.items()
+ }
+ ),
+ encryptionContext=Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ ),
+ selectorContext=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.selector_context.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemOutput(
+ native_input,
+):
+ return DafnyDecryptItemOutput(
+ plaintextItem=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.plaintext_item.items()
+ }
+ ),
+ parsedHeader=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_ParsedHeader(
+ native_input.parsed_header
+ )
+ )
+ )
+ if (native_input.parsed_header is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_AtomicPrimitivesReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DynamoDbItemEncryptorConfig(
+ native_input,
+):
+ return DafnyDynamoDbItemEncryptorConfig(
+ logicalTableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.logical_table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ partitionKeyName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.partition_key_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ sortKeyName=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.sort_key_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.sort_key_name is not None)
+ else (Option_None())
+ ),
+ attributeActionsOnEncrypt=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.attribute_actions_on_encrypt.items()
+ }
+ ),
+ allowedUnsignedAttributes=(
+ (
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input.allowed_unsigned_attributes
+ ]
+ )
+ )
+ )
+ if (native_input.allowed_unsigned_attributes is not None)
+ else (Option_None())
+ ),
+ allowedUnsignedAttributePrefix=(
+ (
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(
+ *[iter(native_input.allowed_unsigned_attribute_prefix.encode("utf-16-be"))] * 2
+ )
+ ]
+ )
+ )
+ )
+ )
+ if (native_input.allowed_unsigned_attribute_prefix is not None)
+ else (Option_None())
+ ),
+ algorithmSuiteId=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ )
+ )
+ )
+ if (native_input.algorithm_suite_id is not None)
+ else (Option_None())
+ ),
+ keyring=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_KeyringReference(
+ native_input.keyring
+ )
+ )
+ )
+ if (
+ (native_input.keyring is not None)
+ and (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_KeyringReference(
+ native_input.keyring
+ )
+ is not None
+ )
+ )
+ else (Option_None())
+ ),
+ cmm=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ )
+ )
+ )
+ if (
+ (native_input.cmm is not None)
+ and (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ )
+ is not None
+ )
+ )
+ else (Option_None())
+ ),
+ legacyOverride=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_LegacyOverride(
+ native_input.legacy_override
+ )
+ )
+ )
+ if (native_input.legacy_override is not None)
+ else (Option_None())
+ ),
+ plaintextOverride=(
+ (
+ Option_Some(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_PlaintextOverride(
+ native_input.plaintext_override
+ )
+ )
+ )
+ if (native_input.plaintext_override is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_StructuredEncryptionReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/__init__.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/aws_sdk_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/aws_sdk_to_dafny.py
new file mode 100644
index 000000000..12d8711b8
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/aws_sdk_to_dafny.py
@@ -0,0 +1,3174 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeAction_ADD,
+ AttributeAction_DELETE,
+ AttributeAction_PUT,
+ AttributeValueUpdate_AttributeValueUpdate as DafnyAttributeValueUpdate,
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+ BatchExecuteStatementInput_BatchExecuteStatementInput as DafnyBatchExecuteStatementInput,
+ BatchExecuteStatementOutput_BatchExecuteStatementOutput as DafnyBatchExecuteStatementOutput,
+ BatchGetItemInput_BatchGetItemInput as DafnyBatchGetItemInput,
+ BatchGetItemOutput_BatchGetItemOutput as DafnyBatchGetItemOutput,
+ BatchStatementErrorCodeEnum_AccessDenied,
+ BatchStatementErrorCodeEnum_ConditionalCheckFailed,
+ BatchStatementErrorCodeEnum_DuplicateItem,
+ BatchStatementErrorCodeEnum_InternalServerError,
+ BatchStatementErrorCodeEnum_ItemCollectionSizeLimitExceeded,
+ BatchStatementErrorCodeEnum_ProvisionedThroughputExceeded,
+ BatchStatementErrorCodeEnum_RequestLimitExceeded,
+ BatchStatementErrorCodeEnum_ResourceNotFound,
+ BatchStatementErrorCodeEnum_ThrottlingError,
+ BatchStatementErrorCodeEnum_TransactionConflict,
+ BatchStatementErrorCodeEnum_ValidationError,
+ BatchStatementError_BatchStatementError as DafnyBatchStatementError,
+ BatchStatementRequest_BatchStatementRequest as DafnyBatchStatementRequest,
+ BatchStatementResponse_BatchStatementResponse as DafnyBatchStatementResponse,
+ BatchWriteItemInput_BatchWriteItemInput as DafnyBatchWriteItemInput,
+ BatchWriteItemOutput_BatchWriteItemOutput as DafnyBatchWriteItemOutput,
+ Capacity_Capacity as DafnyCapacity,
+ ComparisonOperator_BEGINS__WITH,
+ ComparisonOperator_BETWEEN,
+ ComparisonOperator_CONTAINS,
+ ComparisonOperator_EQ,
+ ComparisonOperator_GE,
+ ComparisonOperator_GT,
+ ComparisonOperator_IN,
+ ComparisonOperator_LE,
+ ComparisonOperator_LT,
+ ComparisonOperator_NE,
+ ComparisonOperator_NOT__CONTAINS,
+ ComparisonOperator_NOT__NULL,
+ ComparisonOperator_NULL,
+ ConditionCheck_ConditionCheck as DafnyConditionCheck,
+ Condition_Condition as DafnyCondition,
+ ConditionalOperator_AND,
+ ConditionalOperator_OR,
+ ConsumedCapacity_ConsumedCapacity as DafnyConsumedCapacity,
+ DeleteItemInput_DeleteItemInput as DafnyDeleteItemInput,
+ DeleteItemOutput_DeleteItemOutput as DafnyDeleteItemOutput,
+ DeleteRequest_DeleteRequest as DafnyDeleteRequest,
+ Delete_Delete as DafnyDelete,
+ ExecuteStatementInput_ExecuteStatementInput as DafnyExecuteStatementInput,
+ ExecuteStatementOutput_ExecuteStatementOutput as DafnyExecuteStatementOutput,
+ ExecuteTransactionInput_ExecuteTransactionInput as DafnyExecuteTransactionInput,
+ ExecuteTransactionOutput_ExecuteTransactionOutput as DafnyExecuteTransactionOutput,
+ ExpectedAttributeValue_ExpectedAttributeValue as DafnyExpectedAttributeValue,
+ GetItemInput_GetItemInput as DafnyGetItemInput,
+ GetItemOutput_GetItemOutput as DafnyGetItemOutput,
+ Get_Get as DafnyGet,
+ ItemCollectionMetrics_ItemCollectionMetrics as DafnyItemCollectionMetrics,
+ ItemResponse_ItemResponse as DafnyItemResponse,
+ KeysAndAttributes_KeysAndAttributes as DafnyKeysAndAttributes,
+ ParameterizedStatement_ParameterizedStatement as DafnyParameterizedStatement,
+ PutItemInput_PutItemInput as DafnyPutItemInput,
+ PutItemOutput_PutItemOutput as DafnyPutItemOutput,
+ PutRequest_PutRequest as DafnyPutRequest,
+ Put_Put as DafnyPut,
+ QueryInput_QueryInput as DafnyQueryInput,
+ QueryOutput_QueryOutput as DafnyQueryOutput,
+ ReturnConsumedCapacity_INDEXES,
+ ReturnConsumedCapacity_NONE,
+ ReturnConsumedCapacity_TOTAL,
+ ReturnItemCollectionMetrics_NONE,
+ ReturnItemCollectionMetrics_SIZE,
+ ReturnValue_ALL__NEW,
+ ReturnValue_ALL__OLD,
+ ReturnValue_NONE,
+ ReturnValue_UPDATED__NEW,
+ ReturnValue_UPDATED__OLD,
+ ReturnValuesOnConditionCheckFailure_ALL__OLD,
+ ReturnValuesOnConditionCheckFailure_NONE,
+ ScanInput_ScanInput as DafnyScanInput,
+ ScanOutput_ScanOutput as DafnyScanOutput,
+ Select_ALL__ATTRIBUTES,
+ Select_ALL__PROJECTED__ATTRIBUTES,
+ Select_COUNT,
+ Select_SPECIFIC__ATTRIBUTES,
+ TransactGetItem_TransactGetItem as DafnyTransactGetItem,
+ TransactGetItemsInput_TransactGetItemsInput as DafnyTransactGetItemsInput,
+ TransactGetItemsOutput_TransactGetItemsOutput as DafnyTransactGetItemsOutput,
+ TransactWriteItem_TransactWriteItem as DafnyTransactWriteItem,
+ TransactWriteItemsInput_TransactWriteItemsInput as DafnyTransactWriteItemsInput,
+ TransactWriteItemsOutput_TransactWriteItemsOutput as DafnyTransactWriteItemsOutput,
+ UpdateItemInput_UpdateItemInput as DafnyUpdateItemInput,
+ UpdateItemOutput_UpdateItemOutput as DafnyUpdateItemOutput,
+ Update_Update as DafnyUpdate,
+ WriteRequest_WriteRequest as DafnyWriteRequest,
+)
+import aws_cryptography_internal_dynamodb.internaldafny.generated.module_
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+from smithy_dafny_standard_library.internaldafny.generated.Wrappers import (
+ Option_None,
+ Option_Some,
+)
+
+
+def com_amazonaws_dynamodb_PutItemInput(native_input):
+ return DafnyPutItemInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Item=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ ),
+ Expected=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in native_input["Expected"].items()
+ }
+ )
+ )
+ if "Expected" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValues=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValue(
+ native_input["ReturnValues"]
+ )
+ )
+ if "ReturnValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ native_input["ReturnItemCollectionMetrics"]
+ )
+ )
+ if "ReturnItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionalOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionalOperator(
+ native_input["ConditionalOperator"]
+ )
+ )
+ if "ConditionalOperator" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_AttributeValue(native_input):
+ if "S" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_S(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["S"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "N" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_N(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["N"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ elif "B" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_B(Seq(native_input["B"]))
+ elif "SS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_SS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["SS"]
+ ]
+ )
+ )
+ elif "NS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NS(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["NS"]
+ ]
+ )
+ )
+ elif "BS" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BS(Seq([Seq(list_element) for list_element in native_input["BS"]]))
+ elif "M" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_M(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["M"].items()
+ }
+ )
+ )
+ elif "L" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_L(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["L"]
+ ]
+ )
+ )
+ elif "NULL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_NULL(native_input["NULL"])
+ elif "BOOL" in native_input.keys():
+ AttributeValue_union_value = AttributeValue_BOOL(native_input["BOOL"])
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return AttributeValue_union_value
+
+
+def com_amazonaws_dynamodb_ExpectedAttributeValue(native_input):
+ return DafnyExpectedAttributeValue(
+ Value=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ native_input["Value"]
+ )
+ )
+ if "Value" in native_input.keys()
+ else Option_None()
+ ),
+ Exists=(Option_Some(native_input["Exists"]) if "Exists" in native_input.keys() else Option_None()),
+ ComparisonOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ComparisonOperator(
+ native_input["ComparisonOperator"]
+ )
+ )
+ if "ComparisonOperator" in native_input.keys()
+ else Option_None()
+ ),
+ AttributeValueList=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["AttributeValueList"]
+ ]
+ )
+ )
+ if "AttributeValueList" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ComparisonOperator(native_input):
+ # Convert ComparisonOperator
+ if native_input == "EQ":
+ return ComparisonOperator_EQ()
+ elif native_input == "NE":
+ return ComparisonOperator_NE()
+ elif native_input == "IN":
+ return ComparisonOperator_IN()
+ elif native_input == "LE":
+ return ComparisonOperator_LE()
+ elif native_input == "LT":
+ return ComparisonOperator_LT()
+ elif native_input == "GE":
+ return ComparisonOperator_GE()
+ elif native_input == "GT":
+ return ComparisonOperator_GT()
+ elif native_input == "BETWEEN":
+ return ComparisonOperator_BETWEEN()
+ elif native_input == "NOT_NULL":
+ return ComparisonOperator_NOT__NULL()
+ elif native_input == "NULL":
+ return ComparisonOperator_NULL()
+ elif native_input == "CONTAINS":
+ return ComparisonOperator_CONTAINS()
+ elif native_input == "NOT_CONTAINS":
+ return ComparisonOperator_NOT__CONTAINS()
+ elif native_input == "BEGINS_WITH":
+ return ComparisonOperator_BEGINS__WITH()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ReturnValue(native_input):
+ # Convert ReturnValue
+ if native_input == "NONE":
+ return ReturnValue_NONE()
+ elif native_input == "ALL_OLD":
+ return ReturnValue_ALL__OLD()
+ elif native_input == "UPDATED_OLD":
+ return ReturnValue_UPDATED__OLD()
+ elif native_input == "ALL_NEW":
+ return ReturnValue_ALL__NEW()
+ elif native_input == "UPDATED_NEW":
+ return ReturnValue_UPDATED__NEW()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ReturnConsumedCapacity(native_input):
+ # Convert ReturnConsumedCapacity
+ if native_input == "INDEXES":
+ return ReturnConsumedCapacity_INDEXES()
+ elif native_input == "TOTAL":
+ return ReturnConsumedCapacity_TOTAL()
+ elif native_input == "NONE":
+ return ReturnConsumedCapacity_NONE()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ReturnItemCollectionMetrics(native_input):
+ # Convert ReturnItemCollectionMetrics
+ if native_input == "SIZE":
+ return ReturnItemCollectionMetrics_SIZE()
+ elif native_input == "NONE":
+ return ReturnItemCollectionMetrics_NONE()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ConditionalOperator(native_input):
+ # Convert ConditionalOperator
+ if native_input == "AND":
+ return ConditionalOperator_AND()
+ elif native_input == "OR":
+ return ConditionalOperator_OR()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(native_input):
+ # Convert ReturnValuesOnConditionCheckFailure
+ if native_input == "ALL_OLD":
+ return ReturnValuesOnConditionCheckFailure_ALL__OLD()
+ elif native_input == "NONE":
+ return ReturnValuesOnConditionCheckFailure_NONE()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_PutItemOutput(native_input):
+ return DafnyPutItemOutput(
+ Attributes=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Attributes"].items()
+ }
+ )
+ )
+ if "Attributes" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ native_input["ItemCollectionMetrics"]
+ )
+ )
+ if "ItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ConsumedCapacity(native_input):
+ return DafnyConsumedCapacity(
+ TableName=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "TableName" in native_input.keys()
+ else Option_None()
+ ),
+ CapacityUnits=(
+ Option_Some(native_input["CapacityUnits"]) if "CapacityUnits" in native_input.keys() else Option_None()
+ ),
+ ReadCapacityUnits=(
+ Option_Some(native_input["ReadCapacityUnits"])
+ if "ReadCapacityUnits" in native_input.keys()
+ else Option_None()
+ ),
+ WriteCapacityUnits=(
+ Option_Some(native_input["WriteCapacityUnits"])
+ if "WriteCapacityUnits" in native_input.keys()
+ else Option_None()
+ ),
+ Table=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Capacity(
+ native_input["Table"]
+ )
+ )
+ if "Table" in native_input.keys()
+ else Option_None()
+ ),
+ LocalSecondaryIndexes=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Capacity(
+ value
+ )
+ for (key, value) in native_input["LocalSecondaryIndexes"].items()
+ }
+ )
+ )
+ if "LocalSecondaryIndexes" in native_input.keys()
+ else Option_None()
+ ),
+ GlobalSecondaryIndexes=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Capacity(
+ value
+ )
+ for (key, value) in native_input["GlobalSecondaryIndexes"].items()
+ }
+ )
+ )
+ if "GlobalSecondaryIndexes" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Capacity(native_input):
+ return DafnyCapacity(
+ ReadCapacityUnits=(
+ Option_Some(native_input["ReadCapacityUnits"])
+ if "ReadCapacityUnits" in native_input.keys()
+ else Option_None()
+ ),
+ WriteCapacityUnits=(
+ Option_Some(native_input["WriteCapacityUnits"])
+ if "WriteCapacityUnits" in native_input.keys()
+ else Option_None()
+ ),
+ CapacityUnits=(
+ Option_Some(native_input["CapacityUnits"]) if "CapacityUnits" in native_input.keys() else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ItemCollectionMetrics(native_input):
+ return DafnyItemCollectionMetrics(
+ ItemCollectionKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ItemCollectionKey"].items()
+ }
+ )
+ )
+ if "ItemCollectionKey" in native_input.keys()
+ else Option_None()
+ ),
+ SizeEstimateRangeGB=(
+ Option_Some(Seq([list_element for list_element in native_input["SizeEstimateRangeGB"]]))
+ if "SizeEstimateRangeGB" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_GetItemInput(native_input):
+ return DafnyGetItemInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ AttributesToGet=(
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["AttributesToGet"]
+ ]
+ )
+ )
+ if "AttributesToGet" in native_input.keys()
+ else Option_None()
+ ),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ProjectionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ProjectionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ProjectionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_GetItemOutput(native_input):
+ return DafnyGetItemOutput(
+ Item=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ )
+ )
+ if "Item" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchWriteItemInput(native_input):
+ return DafnyBatchWriteItemInput(
+ RequestItems=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_WriteRequest(
+ list_element
+ )
+ for list_element in value
+ ]
+ )
+ for (key, value) in native_input["RequestItems"].items()
+ }
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ native_input["ReturnItemCollectionMetrics"]
+ )
+ )
+ if "ReturnItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_WriteRequest(native_input):
+ return DafnyWriteRequest(
+ PutRequest=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutRequest(
+ native_input["PutRequest"]
+ )
+ )
+ if "PutRequest" in native_input.keys()
+ else Option_None()
+ ),
+ DeleteRequest=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteRequest(
+ native_input["DeleteRequest"]
+ )
+ )
+ if "DeleteRequest" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_PutRequest(native_input):
+ return DafnyPutRequest(
+ Item=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_DeleteRequest(native_input):
+ return DafnyDeleteRequest(
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchWriteItemOutput(native_input):
+ return DafnyBatchWriteItemOutput(
+ UnprocessedItems=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_WriteRequest(
+ list_element
+ )
+ for list_element in value
+ ]
+ )
+ for (key, value) in native_input["UnprocessedItems"].items()
+ }
+ )
+ )
+ if "UnprocessedItems" in native_input.keys()
+ else Option_None()
+ ),
+ ItemCollectionMetrics=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ list_element
+ )
+ for list_element in value
+ ]
+ )
+ for (key, value) in native_input["ItemCollectionMetrics"].items()
+ }
+ )
+ )
+ if "ItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchGetItemInput(native_input):
+ return DafnyBatchGetItemInput(
+ RequestItems=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_KeysAndAttributes(
+ value
+ )
+ for (key, value) in native_input["RequestItems"].items()
+ }
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_KeysAndAttributes(native_input):
+ return DafnyKeysAndAttributes(
+ Keys=Seq(
+ [
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items()
+ }
+ )
+ for list_element in native_input["Keys"]
+ ]
+ ),
+ AttributesToGet=(
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["AttributesToGet"]
+ ]
+ )
+ )
+ if "AttributesToGet" in native_input.keys()
+ else Option_None()
+ ),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ ProjectionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ProjectionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ProjectionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchGetItemOutput(native_input):
+ return DafnyBatchGetItemOutput(
+ Responses=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ [
+ Map(
+ {
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items()
+ }
+ )
+ for list_element in value
+ ]
+ )
+ for (key, value) in native_input["Responses"].items()
+ }
+ )
+ )
+ if "Responses" in native_input.keys()
+ else Option_None()
+ ),
+ UnprocessedKeys=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_KeysAndAttributes(
+ value
+ )
+ for (key, value) in native_input["UnprocessedKeys"].items()
+ }
+ )
+ )
+ if "UnprocessedKeys" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ScanInput(native_input):
+ return DafnyScanInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ IndexName=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["IndexName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "IndexName" in native_input.keys()
+ else Option_None()
+ ),
+ AttributesToGet=(
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["AttributesToGet"]
+ ]
+ )
+ )
+ if "AttributesToGet" in native_input.keys()
+ else Option_None()
+ ),
+ Limit=(Option_Some(native_input["Limit"]) if "Limit" in native_input.keys() else Option_None()),
+ Select=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Select(
+ native_input["Select"]
+ )
+ )
+ if "Select" in native_input.keys()
+ else Option_None()
+ ),
+ ScanFilter=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in native_input["ScanFilter"].items()
+ }
+ )
+ )
+ if "ScanFilter" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionalOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionalOperator(
+ native_input["ConditionalOperator"]
+ )
+ )
+ if "ConditionalOperator" in native_input.keys()
+ else Option_None()
+ ),
+ ExclusiveStartKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExclusiveStartKey"].items()
+ }
+ )
+ )
+ if "ExclusiveStartKey" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ TotalSegments=(
+ Option_Some(native_input["TotalSegments"]) if "TotalSegments" in native_input.keys() else Option_None()
+ ),
+ Segment=(Option_Some(native_input["Segment"]) if "Segment" in native_input.keys() else Option_None()),
+ ProjectionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ProjectionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ProjectionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ FilterExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["FilterExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "FilterExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Select(native_input):
+ # Convert Select
+ if native_input == "ALL_ATTRIBUTES":
+ return Select_ALL__ATTRIBUTES()
+ elif native_input == "ALL_PROJECTED_ATTRIBUTES":
+ return Select_ALL__PROJECTED__ATTRIBUTES()
+ elif native_input == "SPECIFIC_ATTRIBUTES":
+ return Select_SPECIFIC__ATTRIBUTES()
+ elif native_input == "COUNT":
+ return Select_COUNT()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_Condition(native_input):
+ return DafnyCondition(
+ AttributeValueList=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["AttributeValueList"]
+ ]
+ )
+ )
+ if "AttributeValueList" in native_input.keys()
+ else Option_None()
+ ),
+ ComparisonOperator=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ComparisonOperator(
+ native_input["ComparisonOperator"]
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ScanOutput(native_input):
+ return DafnyScanOutput(
+ Items=(
+ Option_Some(
+ Seq(
+ [
+ Map(
+ {
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items()
+ }
+ )
+ for list_element in native_input["Items"]
+ ]
+ )
+ )
+ if "Items" in native_input.keys()
+ else Option_None()
+ ),
+ Count=(Option_Some(native_input["Count"]) if "Count" in native_input.keys() else Option_None()),
+ ScannedCount=(
+ Option_Some(native_input["ScannedCount"]) if "ScannedCount" in native_input.keys() else Option_None()
+ ),
+ LastEvaluatedKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["LastEvaluatedKey"].items()
+ }
+ )
+ )
+ if "LastEvaluatedKey" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_QueryInput(native_input):
+ return DafnyQueryInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ IndexName=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["IndexName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "IndexName" in native_input.keys()
+ else Option_None()
+ ),
+ Select=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Select(
+ native_input["Select"]
+ )
+ )
+ if "Select" in native_input.keys()
+ else Option_None()
+ ),
+ AttributesToGet=(
+ Option_Some(
+ Seq(
+ [
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for list_element in native_input["AttributesToGet"]
+ ]
+ )
+ )
+ if "AttributesToGet" in native_input.keys()
+ else Option_None()
+ ),
+ Limit=(Option_Some(native_input["Limit"]) if "Limit" in native_input.keys() else Option_None()),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ KeyConditions=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in native_input["KeyConditions"].items()
+ }
+ )
+ )
+ if "KeyConditions" in native_input.keys()
+ else Option_None()
+ ),
+ QueryFilter=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in native_input["QueryFilter"].items()
+ }
+ )
+ )
+ if "QueryFilter" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionalOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionalOperator(
+ native_input["ConditionalOperator"]
+ )
+ )
+ if "ConditionalOperator" in native_input.keys()
+ else Option_None()
+ ),
+ ScanIndexForward=(
+ Option_Some(native_input["ScanIndexForward"])
+ if "ScanIndexForward" in native_input.keys()
+ else Option_None()
+ ),
+ ExclusiveStartKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExclusiveStartKey"].items()
+ }
+ )
+ )
+ if "ExclusiveStartKey" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ProjectionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ProjectionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ProjectionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ FilterExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["FilterExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "FilterExpression" in native_input.keys()
+ else Option_None()
+ ),
+ KeyConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["KeyConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "KeyConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_QueryOutput(native_input):
+ return DafnyQueryOutput(
+ Items=(
+ Option_Some(
+ Seq(
+ [
+ Map(
+ {
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items()
+ }
+ )
+ for list_element in native_input["Items"]
+ ]
+ )
+ )
+ if "Items" in native_input.keys()
+ else Option_None()
+ ),
+ Count=(Option_Some(native_input["Count"]) if "Count" in native_input.keys() else Option_None()),
+ ScannedCount=(
+ Option_Some(native_input["ScannedCount"]) if "ScannedCount" in native_input.keys() else Option_None()
+ ),
+ LastEvaluatedKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["LastEvaluatedKey"].items()
+ }
+ )
+ )
+ if "LastEvaluatedKey" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactWriteItemsInput(native_input):
+ return DafnyTransactWriteItemsInput(
+ TransactItems=Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItem(
+ list_element
+ )
+ for list_element in native_input["TransactItems"]
+ ]
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ native_input["ReturnItemCollectionMetrics"]
+ )
+ )
+ if "ReturnItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ ClientRequestToken=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ClientRequestToken"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ClientRequestToken" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactWriteItem(native_input):
+ return DafnyTransactWriteItem(
+ ConditionCheck=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionCheck(
+ native_input["ConditionCheck"]
+ )
+ )
+ if "ConditionCheck" in native_input.keys()
+ else Option_None()
+ ),
+ Put=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Put(
+ native_input["Put"]
+ )
+ )
+ if "Put" in native_input.keys()
+ else Option_None()
+ ),
+ Delete=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Delete(
+ native_input["Delete"]
+ )
+ )
+ if "Delete" in native_input.keys()
+ else Option_None()
+ ),
+ Update=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Update(
+ native_input["Update"]
+ )
+ )
+ if "Update" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ConditionCheck(native_input):
+ return DafnyConditionCheck(
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ConditionExpression=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Put(native_input):
+ return DafnyPut(
+ Item=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ ),
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Delete(native_input):
+ return DafnyDelete(
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Update(native_input):
+ return DafnyUpdate(
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ UpdateExpression=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["UpdateExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactWriteItemsOutput(native_input):
+ return DafnyTransactWriteItemsOutput(
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ItemCollectionMetrics=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ list_element
+ )
+ for list_element in value
+ ]
+ )
+ for (key, value) in native_input["ItemCollectionMetrics"].items()
+ }
+ )
+ )
+ if "ItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_UpdateItemInput(native_input):
+ return DafnyUpdateItemInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ AttributeUpdates=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValueUpdate(
+ value
+ )
+ for (key, value) in native_input["AttributeUpdates"].items()
+ }
+ )
+ )
+ if "AttributeUpdates" in native_input.keys()
+ else Option_None()
+ ),
+ Expected=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in native_input["Expected"].items()
+ }
+ )
+ )
+ if "Expected" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionalOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionalOperator(
+ native_input["ConditionalOperator"]
+ )
+ )
+ if "ConditionalOperator" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValues=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValue(
+ native_input["ReturnValues"]
+ )
+ )
+ if "ReturnValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ native_input["ReturnItemCollectionMetrics"]
+ )
+ )
+ if "ReturnItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ UpdateExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["UpdateExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "UpdateExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_AttributeValueUpdate(native_input):
+ return DafnyAttributeValueUpdate(
+ Value=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ native_input["Value"]
+ )
+ )
+ if "Value" in native_input.keys()
+ else Option_None()
+ ),
+ Action=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeAction(
+ native_input["Action"]
+ )
+ )
+ if "Action" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_AttributeAction(native_input):
+ # Convert AttributeAction
+ if native_input == "ADD":
+ return AttributeAction_ADD()
+ elif native_input == "PUT":
+ return AttributeAction_PUT()
+ elif native_input == "DELETE":
+ return AttributeAction_DELETE()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_UpdateItemOutput(native_input):
+ return DafnyUpdateItemOutput(
+ Attributes=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Attributes"].items()
+ }
+ )
+ )
+ if "Attributes" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ native_input["ItemCollectionMetrics"]
+ )
+ )
+ if "ItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_DeleteItemInput(native_input):
+ return DafnyDeleteItemInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ Expected=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in native_input["Expected"].items()
+ }
+ )
+ )
+ if "Expected" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionalOperator=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConditionalOperator(
+ native_input["ConditionalOperator"]
+ )
+ )
+ if "ConditionalOperator" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValues=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValue(
+ native_input["ReturnValues"]
+ )
+ )
+ if "ReturnValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ native_input["ReturnItemCollectionMetrics"]
+ )
+ )
+ if "ReturnItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ ConditionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ConditionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ConditionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeValues=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["ExpressionAttributeValues"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeValues" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_DeleteItemOutput(native_input):
+ return DafnyDeleteItemOutput(
+ Attributes=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Attributes"].items()
+ }
+ )
+ )
+ if "Attributes" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ ItemCollectionMetrics=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ native_input["ItemCollectionMetrics"]
+ )
+ )
+ if "ItemCollectionMetrics" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactGetItemsInput(native_input):
+ return DafnyTransactGetItemsInput(
+ TransactItems=Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItem(
+ list_element
+ )
+ for list_element in native_input["TransactItems"]
+ ]
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactGetItem(native_input):
+ return DafnyTransactGetItem(
+ Get=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_Get(
+ native_input["Get"]
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_Get(native_input):
+ return DafnyGet(
+ Key=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Key"].items()
+ }
+ ),
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ ProjectionExpression=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ProjectionExpression"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ProjectionExpression" in native_input.keys()
+ else Option_None()
+ ),
+ ExpressionAttributeNames=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ for (key, value) in native_input["ExpressionAttributeNames"].items()
+ }
+ )
+ )
+ if "ExpressionAttributeNames" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_TransactGetItemsOutput(native_input):
+ return DafnyTransactGetItemsOutput(
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ Responses=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemResponse(
+ list_element
+ )
+ for list_element in native_input["Responses"]
+ ]
+ )
+ )
+ if "Responses" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ItemResponse(native_input):
+ return DafnyItemResponse(
+ Item=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ )
+ )
+ if "Item" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ExecuteStatementInput(native_input):
+ return DafnyExecuteStatementInput(
+ Statement=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["Statement"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Parameters=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["Parameters"]
+ ]
+ )
+ )
+ if "Parameters" in native_input.keys()
+ else Option_None()
+ ),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ NextToken=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["NextToken"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "NextToken" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ Limit=(Option_Some(native_input["Limit"]) if "Limit" in native_input.keys() else Option_None()),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ExecuteStatementOutput(native_input):
+ return DafnyExecuteStatementOutput(
+ Items=(
+ Option_Some(
+ Seq(
+ [
+ Map(
+ {
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items()
+ }
+ )
+ for list_element in native_input["Items"]
+ ]
+ )
+ )
+ if "Items" in native_input.keys()
+ else Option_None()
+ ),
+ NextToken=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["NextToken"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "NextToken" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ native_input["ConsumedCapacity"]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ LastEvaluatedKey=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["LastEvaluatedKey"].items()
+ }
+ )
+ )
+ if "LastEvaluatedKey" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchExecuteStatementInput(native_input):
+ return DafnyBatchExecuteStatementInput(
+ Statements=Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchStatementRequest(
+ list_element
+ )
+ for list_element in native_input["Statements"]
+ ]
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchStatementRequest(native_input):
+ return DafnyBatchStatementRequest(
+ Statement=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["Statement"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Parameters=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["Parameters"]
+ ]
+ )
+ )
+ if "Parameters" in native_input.keys()
+ else Option_None()
+ ),
+ ConsistentRead=(
+ Option_Some(native_input["ConsistentRead"]) if "ConsistentRead" in native_input.keys() else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchExecuteStatementOutput(native_input):
+ return DafnyBatchExecuteStatementOutput(
+ Responses=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchStatementResponse(
+ list_element
+ )
+ for list_element in native_input["Responses"]
+ ]
+ )
+ )
+ if "Responses" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchStatementResponse(native_input):
+ return DafnyBatchStatementResponse(
+ Error=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchStatementError(
+ native_input["Error"]
+ )
+ )
+ if "Error" in native_input.keys()
+ else Option_None()
+ ),
+ TableName=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["TableName"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "TableName" in native_input.keys()
+ else Option_None()
+ ),
+ Item=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ )
+ )
+ if "Item" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchStatementError(native_input):
+ return DafnyBatchStatementError(
+ Code=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchStatementErrorCodeEnum(
+ native_input["Code"]
+ )
+ )
+ if "Code" in native_input.keys()
+ else Option_None()
+ ),
+ Message=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["Message"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "Message" in native_input.keys()
+ else Option_None()
+ ),
+ Item=(
+ Option_Some(
+ Map(
+ {
+ Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
+ )
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input["Item"].items()
+ }
+ )
+ )
+ if "Item" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_BatchStatementErrorCodeEnum(native_input):
+ # Convert BatchStatementErrorCodeEnum
+ if native_input == "ConditionalCheckFailed":
+ return BatchStatementErrorCodeEnum_ConditionalCheckFailed()
+ elif native_input == "ItemCollectionSizeLimitExceeded":
+ return BatchStatementErrorCodeEnum_ItemCollectionSizeLimitExceeded()
+ elif native_input == "RequestLimitExceeded":
+ return BatchStatementErrorCodeEnum_RequestLimitExceeded()
+ elif native_input == "ValidationError":
+ return BatchStatementErrorCodeEnum_ValidationError()
+ elif native_input == "ProvisionedThroughputExceeded":
+ return BatchStatementErrorCodeEnum_ProvisionedThroughputExceeded()
+ elif native_input == "TransactionConflict":
+ return BatchStatementErrorCodeEnum_TransactionConflict()
+ elif native_input == "ThrottlingError":
+ return BatchStatementErrorCodeEnum_ThrottlingError()
+ elif native_input == "InternalServerError":
+ return BatchStatementErrorCodeEnum_InternalServerError()
+ elif native_input == "ResourceNotFound":
+ return BatchStatementErrorCodeEnum_ResourceNotFound()
+ elif native_input == "AccessDenied":
+ return BatchStatementErrorCodeEnum_AccessDenied()
+ elif native_input == "DuplicateItem":
+ return BatchStatementErrorCodeEnum_DuplicateItem()
+ else:
+ raise ValueError("No recognized enum value in enum type: " + native_input)
+
+
+def com_amazonaws_dynamodb_ExecuteTransactionInput(native_input):
+ return DafnyExecuteTransactionInput(
+ TransactStatements=Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ParameterizedStatement(
+ list_element
+ )
+ for list_element in native_input["TransactStatements"]
+ ]
+ ),
+ ClientRequestToken=(
+ Option_Some(
+ Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["ClientRequestToken"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ )
+ )
+ if "ClientRequestToken" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnConsumedCapacity=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ native_input["ReturnConsumedCapacity"]
+ )
+ )
+ if "ReturnConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ParameterizedStatement(native_input):
+ return DafnyParameterizedStatement(
+ Statement=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input["Statement"].encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Parameters=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in native_input["Parameters"]
+ ]
+ )
+ )
+ if "Parameters" in native_input.keys()
+ else Option_None()
+ ),
+ ReturnValuesOnConditionCheckFailure=(
+ Option_Some(
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ native_input["ReturnValuesOnConditionCheckFailure"]
+ )
+ )
+ if "ReturnValuesOnConditionCheckFailure" in native_input.keys()
+ else Option_None()
+ ),
+ )
+
+
+def com_amazonaws_dynamodb_ExecuteTransactionOutput(native_input):
+ return DafnyExecuteTransactionOutput(
+ Responses=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ItemResponse(
+ list_element
+ )
+ for list_element in native_input["Responses"]
+ ]
+ )
+ )
+ if "Responses" in native_input.keys()
+ else Option_None()
+ ),
+ ConsumedCapacity=(
+ Option_Some(
+ Seq(
+ [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in native_input["ConsumedCapacity"]
+ ]
+ )
+ )
+ if "ConsumedCapacity" in native_input.keys()
+ else Option_None()
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/client.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/client.py
new file mode 100644
index 000000000..dfb98d3f7
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/client.py
@@ -0,0 +1,820 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes import (
+ IDynamoDbEncryptionTransformsClient,
+)
+from typing import Callable, TypeVar, cast
+
+from .config import Config, DynamoDbTablesEncryptionConfig
+from .dafny_protocol import DafnyRequest, DafnyResponse
+from .plugin import set_config_impl
+from smithy_python.exceptions import SmithyRetryException
+from smithy_python.interfaces.interceptor import Interceptor, InterceptorContext
+from smithy_python.interfaces.retries import RetryErrorInfo, RetryErrorType
+
+from .config import Plugin
+from .deserialize import (
+ _deserialize_batch_execute_statement_input_transform,
+ _deserialize_batch_execute_statement_output_transform,
+ _deserialize_batch_get_item_input_transform,
+ _deserialize_batch_get_item_output_transform,
+ _deserialize_batch_write_item_input_transform,
+ _deserialize_batch_write_item_output_transform,
+ _deserialize_delete_item_input_transform,
+ _deserialize_delete_item_output_transform,
+ _deserialize_execute_statement_input_transform,
+ _deserialize_execute_statement_output_transform,
+ _deserialize_execute_transaction_input_transform,
+ _deserialize_execute_transaction_output_transform,
+ _deserialize_get_item_input_transform,
+ _deserialize_get_item_output_transform,
+ _deserialize_put_item_input_transform,
+ _deserialize_put_item_output_transform,
+ _deserialize_query_input_transform,
+ _deserialize_query_output_transform,
+ _deserialize_resolve_attributes,
+ _deserialize_scan_input_transform,
+ _deserialize_scan_output_transform,
+ _deserialize_transact_get_items_input_transform,
+ _deserialize_transact_get_items_output_transform,
+ _deserialize_transact_write_items_input_transform,
+ _deserialize_transact_write_items_output_transform,
+ _deserialize_update_item_input_transform,
+ _deserialize_update_item_output_transform,
+)
+from .errors import ServiceError
+from .models import (
+ BatchExecuteStatementInputTransformInput,
+ BatchExecuteStatementInputTransformOutput,
+ BatchExecuteStatementOutputTransformInput,
+ BatchExecuteStatementOutputTransformOutput,
+ BatchGetItemInputTransformInput,
+ BatchGetItemInputTransformOutput,
+ BatchGetItemOutputTransformInput,
+ BatchGetItemOutputTransformOutput,
+ BatchWriteItemInputTransformInput,
+ BatchWriteItemInputTransformOutput,
+ BatchWriteItemOutputTransformInput,
+ BatchWriteItemOutputTransformOutput,
+ DeleteItemInputTransformInput,
+ DeleteItemInputTransformOutput,
+ DeleteItemOutputTransformInput,
+ DeleteItemOutputTransformOutput,
+ ExecuteStatementInputTransformInput,
+ ExecuteStatementInputTransformOutput,
+ ExecuteStatementOutputTransformInput,
+ ExecuteStatementOutputTransformOutput,
+ ExecuteTransactionInputTransformInput,
+ ExecuteTransactionInputTransformOutput,
+ ExecuteTransactionOutputTransformInput,
+ ExecuteTransactionOutputTransformOutput,
+ GetItemInputTransformInput,
+ GetItemInputTransformOutput,
+ GetItemOutputTransformInput,
+ GetItemOutputTransformOutput,
+ PutItemInputTransformInput,
+ PutItemInputTransformOutput,
+ PutItemOutputTransformInput,
+ PutItemOutputTransformOutput,
+ QueryInputTransformInput,
+ QueryInputTransformOutput,
+ QueryOutputTransformInput,
+ QueryOutputTransformOutput,
+ ResolveAttributesInput,
+ ResolveAttributesOutput,
+ ScanInputTransformInput,
+ ScanInputTransformOutput,
+ ScanOutputTransformInput,
+ ScanOutputTransformOutput,
+ TransactGetItemsInputTransformInput,
+ TransactGetItemsInputTransformOutput,
+ TransactGetItemsOutputTransformInput,
+ TransactGetItemsOutputTransformOutput,
+ TransactWriteItemsInputTransformInput,
+ TransactWriteItemsInputTransformOutput,
+ TransactWriteItemsOutputTransformInput,
+ TransactWriteItemsOutputTransformOutput,
+ UpdateItemInputTransformInput,
+ UpdateItemInputTransformOutput,
+ UpdateItemOutputTransformInput,
+ UpdateItemOutputTransformOutput,
+)
+from .serialize import (
+ _serialize_batch_execute_statement_input_transform,
+ _serialize_batch_execute_statement_output_transform,
+ _serialize_batch_get_item_input_transform,
+ _serialize_batch_get_item_output_transform,
+ _serialize_batch_write_item_input_transform,
+ _serialize_batch_write_item_output_transform,
+ _serialize_delete_item_input_transform,
+ _serialize_delete_item_output_transform,
+ _serialize_execute_statement_input_transform,
+ _serialize_execute_statement_output_transform,
+ _serialize_execute_transaction_input_transform,
+ _serialize_execute_transaction_output_transform,
+ _serialize_get_item_input_transform,
+ _serialize_get_item_output_transform,
+ _serialize_put_item_input_transform,
+ _serialize_put_item_output_transform,
+ _serialize_query_input_transform,
+ _serialize_query_output_transform,
+ _serialize_resolve_attributes,
+ _serialize_scan_input_transform,
+ _serialize_scan_output_transform,
+ _serialize_transact_get_items_input_transform,
+ _serialize_transact_get_items_output_transform,
+ _serialize_transact_write_items_input_transform,
+ _serialize_transact_write_items_output_transform,
+ _serialize_update_item_input_transform,
+ _serialize_update_item_output_transform,
+)
+
+
+Input = TypeVar("Input")
+Output = TypeVar("Output")
+
+
+class DynamoDbEncryptionTransforms:
+ """Client for DynamoDbEncryptionTransforms.
+
+ :param config: Configuration for the client.
+ """
+
+ def __init__(
+ self,
+ config: DynamoDbTablesEncryptionConfig | None = None,
+ dafny_client: IDynamoDbEncryptionTransformsClient | None = None,
+ ):
+ if config is None:
+ self._config = Config()
+ else:
+ self._config = config
+
+ client_plugins: list[Plugin] = [
+ set_config_impl,
+ ]
+
+ for plugin in client_plugins:
+ plugin(self._config)
+
+ if dafny_client is not None:
+ self._config.dafnyImplInterface.impl = dafny_client
+
+ def put_item_input_transform(self, input: PutItemInputTransformInput) -> PutItemInputTransformOutput:
+ """Invokes the PutItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_put_item_input_transform,
+ deserialize=_deserialize_put_item_input_transform,
+ config=self._config,
+ operation_name="PutItemInputTransform",
+ )
+
+ def put_item_output_transform(self, input: PutItemOutputTransformInput) -> PutItemOutputTransformOutput:
+ """Invokes the PutItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_put_item_output_transform,
+ deserialize=_deserialize_put_item_output_transform,
+ config=self._config,
+ operation_name="PutItemOutputTransform",
+ )
+
+ def get_item_input_transform(self, input: GetItemInputTransformInput) -> GetItemInputTransformOutput:
+ """Invokes the GetItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_get_item_input_transform,
+ deserialize=_deserialize_get_item_input_transform,
+ config=self._config,
+ operation_name="GetItemInputTransform",
+ )
+
+ def get_item_output_transform(self, input: GetItemOutputTransformInput) -> GetItemOutputTransformOutput:
+ """Invokes the GetItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_get_item_output_transform,
+ deserialize=_deserialize_get_item_output_transform,
+ config=self._config,
+ operation_name="GetItemOutputTransform",
+ )
+
+ def batch_write_item_input_transform(
+ self, input: BatchWriteItemInputTransformInput
+ ) -> BatchWriteItemInputTransformOutput:
+ """Invokes the BatchWriteItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_write_item_input_transform,
+ deserialize=_deserialize_batch_write_item_input_transform,
+ config=self._config,
+ operation_name="BatchWriteItemInputTransform",
+ )
+
+ def batch_write_item_output_transform(
+ self, input: BatchWriteItemOutputTransformInput
+ ) -> BatchWriteItemOutputTransformOutput:
+ """Invokes the BatchWriteItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_write_item_output_transform,
+ deserialize=_deserialize_batch_write_item_output_transform,
+ config=self._config,
+ operation_name="BatchWriteItemOutputTransform",
+ )
+
+ def batch_get_item_input_transform(
+ self, input: BatchGetItemInputTransformInput
+ ) -> BatchGetItemInputTransformOutput:
+ """Invokes the BatchGetItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_get_item_input_transform,
+ deserialize=_deserialize_batch_get_item_input_transform,
+ config=self._config,
+ operation_name="BatchGetItemInputTransform",
+ )
+
+ def batch_get_item_output_transform(
+ self, input: BatchGetItemOutputTransformInput
+ ) -> BatchGetItemOutputTransformOutput:
+ """Invokes the BatchGetItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_get_item_output_transform,
+ deserialize=_deserialize_batch_get_item_output_transform,
+ config=self._config,
+ operation_name="BatchGetItemOutputTransform",
+ )
+
+ def scan_input_transform(self, input: ScanInputTransformInput) -> ScanInputTransformOutput:
+ """Invokes the ScanInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_scan_input_transform,
+ deserialize=_deserialize_scan_input_transform,
+ config=self._config,
+ operation_name="ScanInputTransform",
+ )
+
+ def scan_output_transform(self, input: ScanOutputTransformInput) -> ScanOutputTransformOutput:
+ """Invokes the ScanOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_scan_output_transform,
+ deserialize=_deserialize_scan_output_transform,
+ config=self._config,
+ operation_name="ScanOutputTransform",
+ )
+
+ def query_input_transform(self, input: QueryInputTransformInput) -> QueryInputTransformOutput:
+ """Invokes the QueryInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_query_input_transform,
+ deserialize=_deserialize_query_input_transform,
+ config=self._config,
+ operation_name="QueryInputTransform",
+ )
+
+ def query_output_transform(self, input: QueryOutputTransformInput) -> QueryOutputTransformOutput:
+ """Invokes the QueryOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_query_output_transform,
+ deserialize=_deserialize_query_output_transform,
+ config=self._config,
+ operation_name="QueryOutputTransform",
+ )
+
+ def transact_write_items_input_transform(
+ self, input: TransactWriteItemsInputTransformInput
+ ) -> TransactWriteItemsInputTransformOutput:
+ """Invokes the TransactWriteItemsInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_transact_write_items_input_transform,
+ deserialize=_deserialize_transact_write_items_input_transform,
+ config=self._config,
+ operation_name="TransactWriteItemsInputTransform",
+ )
+
+ def transact_write_items_output_transform(
+ self, input: TransactWriteItemsOutputTransformInput
+ ) -> TransactWriteItemsOutputTransformOutput:
+ """Invokes the TransactWriteItemsOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_transact_write_items_output_transform,
+ deserialize=_deserialize_transact_write_items_output_transform,
+ config=self._config,
+ operation_name="TransactWriteItemsOutputTransform",
+ )
+
+ def update_item_input_transform(self, input: UpdateItemInputTransformInput) -> UpdateItemInputTransformOutput:
+ """Invokes the UpdateItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_update_item_input_transform,
+ deserialize=_deserialize_update_item_input_transform,
+ config=self._config,
+ operation_name="UpdateItemInputTransform",
+ )
+
+ def update_item_output_transform(self, input: UpdateItemOutputTransformInput) -> UpdateItemOutputTransformOutput:
+ """Invokes the UpdateItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_update_item_output_transform,
+ deserialize=_deserialize_update_item_output_transform,
+ config=self._config,
+ operation_name="UpdateItemOutputTransform",
+ )
+
+ def delete_item_input_transform(self, input: DeleteItemInputTransformInput) -> DeleteItemInputTransformOutput:
+ """Invokes the DeleteItemInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_delete_item_input_transform,
+ deserialize=_deserialize_delete_item_input_transform,
+ config=self._config,
+ operation_name="DeleteItemInputTransform",
+ )
+
+ def delete_item_output_transform(self, input: DeleteItemOutputTransformInput) -> DeleteItemOutputTransformOutput:
+ """Invokes the DeleteItemOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_delete_item_output_transform,
+ deserialize=_deserialize_delete_item_output_transform,
+ config=self._config,
+ operation_name="DeleteItemOutputTransform",
+ )
+
+ def transact_get_items_input_transform(
+ self, input: TransactGetItemsInputTransformInput
+ ) -> TransactGetItemsInputTransformOutput:
+ """Invokes the TransactGetItemsInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_transact_get_items_input_transform,
+ deserialize=_deserialize_transact_get_items_input_transform,
+ config=self._config,
+ operation_name="TransactGetItemsInputTransform",
+ )
+
+ def transact_get_items_output_transform(
+ self, input: TransactGetItemsOutputTransformInput
+ ) -> TransactGetItemsOutputTransformOutput:
+ """Invokes the TransactGetItemsOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_transact_get_items_output_transform,
+ deserialize=_deserialize_transact_get_items_output_transform,
+ config=self._config,
+ operation_name="TransactGetItemsOutputTransform",
+ )
+
+ def execute_statement_input_transform(
+ self, input: ExecuteStatementInputTransformInput
+ ) -> ExecuteStatementInputTransformOutput:
+ """Invokes the ExecuteStatementInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_execute_statement_input_transform,
+ deserialize=_deserialize_execute_statement_input_transform,
+ config=self._config,
+ operation_name="ExecuteStatementInputTransform",
+ )
+
+ def execute_statement_output_transform(
+ self, input: ExecuteStatementOutputTransformInput
+ ) -> ExecuteStatementOutputTransformOutput:
+ """Invokes the ExecuteStatementOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_execute_statement_output_transform,
+ deserialize=_deserialize_execute_statement_output_transform,
+ config=self._config,
+ operation_name="ExecuteStatementOutputTransform",
+ )
+
+ def batch_execute_statement_input_transform(
+ self, input: BatchExecuteStatementInputTransformInput
+ ) -> BatchExecuteStatementInputTransformOutput:
+ """Invokes the BatchExecuteStatementInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_execute_statement_input_transform,
+ deserialize=_deserialize_batch_execute_statement_input_transform,
+ config=self._config,
+ operation_name="BatchExecuteStatementInputTransform",
+ )
+
+ def batch_execute_statement_output_transform(
+ self, input: BatchExecuteStatementOutputTransformInput
+ ) -> BatchExecuteStatementOutputTransformOutput:
+ """Invokes the BatchExecuteStatementOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_batch_execute_statement_output_transform,
+ deserialize=_deserialize_batch_execute_statement_output_transform,
+ config=self._config,
+ operation_name="BatchExecuteStatementOutputTransform",
+ )
+
+ def execute_transaction_input_transform(
+ self, input: ExecuteTransactionInputTransformInput
+ ) -> ExecuteTransactionInputTransformOutput:
+ """Invokes the ExecuteTransactionInputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_execute_transaction_input_transform,
+ deserialize=_deserialize_execute_transaction_input_transform,
+ config=self._config,
+ operation_name="ExecuteTransactionInputTransform",
+ )
+
+ def execute_transaction_output_transform(
+ self, input: ExecuteTransactionOutputTransformInput
+ ) -> ExecuteTransactionOutputTransformOutput:
+ """Invokes the ExecuteTransactionOutputTransform operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_execute_transaction_output_transform,
+ deserialize=_deserialize_execute_transaction_output_transform,
+ config=self._config,
+ operation_name="ExecuteTransactionOutputTransform",
+ )
+
+ def resolve_attributes(self, input: ResolveAttributesInput) -> ResolveAttributesOutput:
+ """Given an Item, show the intermediate values (e.g. compound beacons,
+ virtual fields).
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_resolve_attributes,
+ deserialize=_deserialize_resolve_attributes,
+ config=self._config,
+ operation_name="ResolveAttributes",
+ )
+
+ def _execute_operation(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ try:
+ return self._handle_execution(input, plugins, serialize, deserialize, config, operation_name)
+ except Exception as e:
+ # Make sure every exception that we throw is an instance of ServiceError so
+ # customers can reliably catch everything we throw.
+ if not isinstance(e, ServiceError):
+ raise ServiceError(e) from e
+ raise e
+
+ def _handle_execution(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ context: InterceptorContext[Input, None, None, None] = InterceptorContext(
+ request=input,
+ response=None,
+ transport_request=None,
+ transport_response=None,
+ )
+ try:
+ _client_interceptors = config.interceptors
+ except AttributeError:
+ config.interceptors = []
+ _client_interceptors = config.interceptors
+ client_interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+ interceptors = client_interceptors
+
+ try:
+ # Step 1a: Invoke read_before_execution on client-level interceptors
+ for interceptor in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 1b: Run operation-level plugins
+ for plugin in plugins:
+ plugin(config)
+
+ _client_interceptors = config.interceptors
+ interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+
+ # Step 1c: Invoke the read_before_execution hooks on newly added
+ # interceptors.
+ for interceptor in interceptors:
+ if interceptor not in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 2: Invoke the modify_before_serialization hooks
+ for interceptor in interceptors:
+ context._request = interceptor.modify_before_serialization(context)
+
+ # Step 3: Invoke the read_before_serialization hooks
+ for interceptor in interceptors:
+ interceptor.read_before_serialization(context)
+
+ # Step 4: Serialize the request
+ context_with_transport_request = cast(InterceptorContext[Input, None, DafnyRequest, None], context)
+ context_with_transport_request._transport_request = serialize(
+ context_with_transport_request.request, config
+ )
+
+ # Step 5: Invoke read_after_serialization
+ for interceptor in interceptors:
+ interceptor.read_after_serialization(context_with_transport_request)
+
+ # Step 6: Invoke modify_before_retry_loop
+ for interceptor in interceptors:
+ context_with_transport_request._transport_request = interceptor.modify_before_retry_loop(
+ context_with_transport_request
+ )
+
+ # Step 7: Acquire the retry token.
+ retry_strategy = config.retry_strategy
+ retry_token = retry_strategy.acquire_initial_retry_token()
+
+ while True:
+ # Make an attempt, creating a copy of the context so we don't pass
+ # around old data.
+ context_with_response = self._handle_attempt(
+ deserialize,
+ interceptors,
+ context_with_transport_request.copy(),
+ config,
+ operation_name,
+ )
+
+ # We perform this type-ignored re-assignment because `context` needs
+ # to point at the latest context so it can be generically handled
+ # later on. This is only an issue here because we've created a copy,
+ # so we're no longer simply pointing at the same object in memory
+ # with different names and type hints. It is possible to address this
+ # without having to fall back to the type ignore, but it would impose
+ # unnecessary runtime costs.
+ context = context_with_response # type: ignore
+
+ if isinstance(context_with_response.response, Exception):
+ # Step 7u: Reacquire retry token if the attempt failed
+ try:
+ retry_token = retry_strategy.refresh_retry_token_for_retry(
+ token_to_renew=retry_token,
+ error_info=RetryErrorInfo(
+ # TODO: Determine the error type.
+ error_type=RetryErrorType.CLIENT_ERROR,
+ ),
+ )
+ except SmithyRetryException:
+ raise context_with_response.response
+ else:
+ # Step 8: Invoke record_success
+ retry_strategy.record_success(token=retry_token)
+ break
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request will have been definitively set, and
+ # The response will be set either with the modeled output or an exception. The
+ # transport_request and transport_response may be set or None.
+ execution_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_execution(interceptors, execution_context)
+
+ def _handle_attempt(
+ self,
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, None, DafnyRequest, None],
+ config: Config,
+ operation_name: str,
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ try:
+ # Step 7a: Invoke read_before_attempt
+ for interceptor in interceptors:
+ interceptor.read_before_attempt(context)
+
+ # Step 7m: Involve client Dafny impl
+ if config.dafnyImplInterface.impl is None:
+ raise Exception("No impl found on the operation config.")
+
+ context_with_response = cast(InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context)
+
+ context_with_response._transport_response = config.dafnyImplInterface.handle_request(
+ input=context_with_response.transport_request
+ )
+
+ # Step 7n: Invoke read_after_transmit
+ for interceptor in interceptors:
+ interceptor.read_after_transmit(context_with_response)
+
+ # Step 7o: Invoke modify_before_deserialization
+ for interceptor in interceptors:
+ context_with_response._transport_response = interceptor.modify_before_deserialization(
+ context_with_response
+ )
+
+ # Step 7p: Invoke read_before_deserialization
+ for interceptor in interceptors:
+ interceptor.read_before_deserialization(context_with_response)
+
+ # Step 7q: deserialize
+ context_with_output = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse],
+ context_with_response,
+ )
+ context_with_output._response = deserialize(context_with_output._transport_response, config)
+
+ # Step 7r: Invoke read_after_deserialization
+ for interceptor in interceptors:
+ interceptor.read_after_deserialization(context_with_output)
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request and transport_request have definitively been set,
+ # the response is either set or an exception, and the transport_resposne is either set or
+ # None. This will also be true after _finalize_attempt because there is no opportunity
+ # there to set the transport_response.
+ attempt_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_attempt(interceptors, attempt_context)
+
+ def _finalize_attempt(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ # Step 7s: Invoke modify_before_attempt_completion
+ try:
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_attempt_completion(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 7t: Invoke read_after_attempt
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_attempt(context)
+ except Exception as e:
+ context._response = e
+
+ return context
+
+ def _finalize_execution(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ ) -> Output:
+ try:
+ # Step 9: Invoke modify_before_completion
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_completion(context)
+
+ except Exception as e:
+ context._response = e
+
+ # Step 11: Invoke read_after_execution
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_execution(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 12: Return / throw
+ if isinstance(context.response, Exception):
+ raise context.response
+
+ # We may want to add some aspects of this context to the output types so we can
+ # return it to the end-users.
+ return context.response
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/config.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/config.py
new file mode 100644
index 000000000..b41b0b30b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/config.py
@@ -0,0 +1,70 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ DynamoDbTablesEncryptionConfig_DynamoDbTablesEncryptionConfig as DafnyDynamoDbTablesEncryptionConfig,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models import (
+ DynamoDbTablesEncryptionConfig,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+from dataclasses import dataclass
+from typing import Any, Callable, TypeAlias
+
+from .dafnyImplInterface import DafnyImplInterface
+from smithy_python._private.retries import SimpleRetryStrategy
+from smithy_python.interfaces.retries import RetryStrategy
+
+
+_ServiceInterceptor = Any
+
+
+@dataclass(init=False)
+class Config:
+ """Configuration for DynamoDbEncryptionTransforms."""
+
+ interceptors: list[_ServiceInterceptor]
+ retry_strategy: RetryStrategy
+ dafnyImplInterface: DafnyImplInterface | None
+
+ def __init__(
+ self,
+ *,
+ interceptors: list[_ServiceInterceptor] | None = None,
+ retry_strategy: RetryStrategy | None = None,
+ dafnyImplInterface: DafnyImplInterface | None = None,
+ ):
+ """Constructor.
+
+ :param interceptors: The list of interceptors, which are hooks
+ that are called during the execution of a request.
+ :param retry_strategy: The retry strategy for issuing retry
+ tokens and computing retry delays.
+ :param dafnyImplInterface:
+ """
+ self.interceptors = interceptors or []
+ self.retry_strategy = retry_strategy or SimpleRetryStrategy()
+ self.dafnyImplInterface = dafnyImplInterface
+
+
+# A callable that allows customizing the config object on each request.
+Plugin: TypeAlias = Callable[[Config], None]
+
+
+def dafny_config_to_smithy_config(dafny_config) -> DynamoDbTablesEncryptionConfig:
+ """Converts the provided Dafny shape for this localService's config into
+ the corresponding Smithy-modelled shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTablesEncryptionConfig(
+ dafny_config
+ )
+
+
+def smithy_config_to_dafny_config(smithy_config) -> DafnyDynamoDbTablesEncryptionConfig:
+ """Converts the provided Smithy-modelled shape for this localService's
+ config into the corresponding Dafny shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_DynamoDbTablesEncryptionConfig(
+ smithy_config
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafnyImplInterface.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafnyImplInterface.py
new file mode 100644
index 000000000..68d924bc1
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafnyImplInterface.py
@@ -0,0 +1,59 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbEncryptionTransforms import (
+ DynamoDbEncryptionTransformsClient,
+)
+from .dafny_protocol import DafnyRequest
+
+
+class DafnyImplInterface:
+ impl: DynamoDbEncryptionTransformsClient | None = None
+
+ # operation_map cannot be created at dafnyImplInterface create time,
+ # as the map's values reference values inside `self.impl`,
+ # and impl is only populated at runtime.
+ # Accessing these before impl is populated results in an error.
+ # At runtime, the map is populated once and cached.
+ operation_map = None
+
+ def handle_request(self, input: DafnyRequest):
+ if self.operation_map is None:
+ self.operation_map = {
+ "PutItemInputTransform": self.impl.PutItemInputTransform,
+ "PutItemOutputTransform": self.impl.PutItemOutputTransform,
+ "GetItemInputTransform": self.impl.GetItemInputTransform,
+ "GetItemOutputTransform": self.impl.GetItemOutputTransform,
+ "BatchWriteItemInputTransform": self.impl.BatchWriteItemInputTransform,
+ "BatchWriteItemOutputTransform": self.impl.BatchWriteItemOutputTransform,
+ "BatchGetItemInputTransform": self.impl.BatchGetItemInputTransform,
+ "BatchGetItemOutputTransform": self.impl.BatchGetItemOutputTransform,
+ "ScanInputTransform": self.impl.ScanInputTransform,
+ "ScanOutputTransform": self.impl.ScanOutputTransform,
+ "QueryInputTransform": self.impl.QueryInputTransform,
+ "QueryOutputTransform": self.impl.QueryOutputTransform,
+ "TransactWriteItemsInputTransform": self.impl.TransactWriteItemsInputTransform,
+ "TransactWriteItemsOutputTransform": self.impl.TransactWriteItemsOutputTransform,
+ "UpdateItemInputTransform": self.impl.UpdateItemInputTransform,
+ "UpdateItemOutputTransform": self.impl.UpdateItemOutputTransform,
+ "DeleteItemInputTransform": self.impl.DeleteItemInputTransform,
+ "DeleteItemOutputTransform": self.impl.DeleteItemOutputTransform,
+ "TransactGetItemsInputTransform": self.impl.TransactGetItemsInputTransform,
+ "TransactGetItemsOutputTransform": self.impl.TransactGetItemsOutputTransform,
+ "ExecuteStatementInputTransform": self.impl.ExecuteStatementInputTransform,
+ "ExecuteStatementOutputTransform": self.impl.ExecuteStatementOutputTransform,
+ "BatchExecuteStatementInputTransform": self.impl.BatchExecuteStatementInputTransform,
+ "BatchExecuteStatementOutputTransform": self.impl.BatchExecuteStatementOutputTransform,
+ "ExecuteTransactionInputTransform": self.impl.ExecuteTransactionInputTransform,
+ "ExecuteTransactionOutputTransform": self.impl.ExecuteTransactionOutputTransform,
+ "ResolveAttributes": self.impl.ResolveAttributes,
+ }
+
+ # This logic is where a typical Smithy client would expect the "server" to be.
+ # This code can be thought of as logic our Dafny "server" uses
+ # to route incoming client requests to the correct request handler code.
+ if input.dafny_operation_input is None:
+ return self.operation_map[input.operation_name]()
+ else:
+ return self.operation_map[input.operation_name](input.dafny_operation_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_protocol.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_protocol.py
new file mode 100644
index 000000000..1da8aec1a
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_protocol.py
@@ -0,0 +1,83 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes import (
+ BatchExecuteStatementInputTransformInput_BatchExecuteStatementInputTransformInput as DafnyBatchExecuteStatementInputTransformInput,
+ BatchExecuteStatementOutputTransformInput_BatchExecuteStatementOutputTransformInput as DafnyBatchExecuteStatementOutputTransformInput,
+ BatchGetItemInputTransformInput_BatchGetItemInputTransformInput as DafnyBatchGetItemInputTransformInput,
+ BatchGetItemOutputTransformInput_BatchGetItemOutputTransformInput as DafnyBatchGetItemOutputTransformInput,
+ BatchWriteItemInputTransformInput_BatchWriteItemInputTransformInput as DafnyBatchWriteItemInputTransformInput,
+ BatchWriteItemOutputTransformInput_BatchWriteItemOutputTransformInput as DafnyBatchWriteItemOutputTransformInput,
+ DeleteItemInputTransformInput_DeleteItemInputTransformInput as DafnyDeleteItemInputTransformInput,
+ DeleteItemOutputTransformInput_DeleteItemOutputTransformInput as DafnyDeleteItemOutputTransformInput,
+ ExecuteStatementInputTransformInput_ExecuteStatementInputTransformInput as DafnyExecuteStatementInputTransformInput,
+ ExecuteStatementOutputTransformInput_ExecuteStatementOutputTransformInput as DafnyExecuteStatementOutputTransformInput,
+ ExecuteTransactionInputTransformInput_ExecuteTransactionInputTransformInput as DafnyExecuteTransactionInputTransformInput,
+ ExecuteTransactionOutputTransformInput_ExecuteTransactionOutputTransformInput as DafnyExecuteTransactionOutputTransformInput,
+ GetItemInputTransformInput_GetItemInputTransformInput as DafnyGetItemInputTransformInput,
+ GetItemOutputTransformInput_GetItemOutputTransformInput as DafnyGetItemOutputTransformInput,
+ PutItemInputTransformInput_PutItemInputTransformInput as DafnyPutItemInputTransformInput,
+ PutItemOutputTransformInput_PutItemOutputTransformInput as DafnyPutItemOutputTransformInput,
+ QueryInputTransformInput_QueryInputTransformInput as DafnyQueryInputTransformInput,
+ QueryOutputTransformInput_QueryOutputTransformInput as DafnyQueryOutputTransformInput,
+ ResolveAttributesInput_ResolveAttributesInput as DafnyResolveAttributesInput,
+ ScanInputTransformInput_ScanInputTransformInput as DafnyScanInputTransformInput,
+ ScanOutputTransformInput_ScanOutputTransformInput as DafnyScanOutputTransformInput,
+ TransactGetItemsInputTransformInput_TransactGetItemsInputTransformInput as DafnyTransactGetItemsInputTransformInput,
+ TransactGetItemsOutputTransformInput_TransactGetItemsOutputTransformInput as DafnyTransactGetItemsOutputTransformInput,
+ TransactWriteItemsInputTransformInput_TransactWriteItemsInputTransformInput as DafnyTransactWriteItemsInputTransformInput,
+ TransactWriteItemsOutputTransformInput_TransactWriteItemsOutputTransformInput as DafnyTransactWriteItemsOutputTransformInput,
+ UpdateItemInputTransformInput_UpdateItemInputTransformInput as DafnyUpdateItemInputTransformInput,
+ UpdateItemOutputTransformInput_UpdateItemOutputTransformInput as DafnyUpdateItemOutputTransformInput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+from typing import Union
+
+
+class DafnyRequest:
+ operation_name: str
+
+ # dafny_operation_input can take on any one of the types
+ # of the input values passed to the Dafny implementation
+ dafny_operation_input: Union[
+ DafnyTransactWriteItemsInputTransformInput,
+ DafnyExecuteTransactionInputTransformInput,
+ DafnyBatchExecuteStatementOutputTransformInput,
+ DafnyQueryOutputTransformInput,
+ DafnyExecuteStatementOutputTransformInput,
+ DafnyDeleteItemInputTransformInput,
+ DafnyBatchGetItemOutputTransformInput,
+ DafnyQueryInputTransformInput,
+ DafnyTransactWriteItemsOutputTransformInput,
+ DafnyPutItemOutputTransformInput,
+ DafnyBatchWriteItemOutputTransformInput,
+ DafnyUpdateItemOutputTransformInput,
+ DafnyUpdateItemInputTransformInput,
+ DafnyExecuteStatementInputTransformInput,
+ DafnyBatchGetItemInputTransformInput,
+ DafnyTransactGetItemsOutputTransformInput,
+ DafnyGetItemInputTransformInput,
+ DafnyBatchExecuteStatementInputTransformInput,
+ DafnyBatchWriteItemInputTransformInput,
+ DafnyDeleteItemOutputTransformInput,
+ DafnyExecuteTransactionOutputTransformInput,
+ DafnyResolveAttributesInput,
+ DafnyTransactGetItemsInputTransformInput,
+ DafnyScanInputTransformInput,
+ DafnyPutItemInputTransformInput,
+ DafnyGetItemOutputTransformInput,
+ DafnyScanOutputTransformInput,
+ ]
+
+ def __init__(self, operation_name, dafny_operation_input):
+ self.operation_name = operation_name
+ self.dafny_operation_input = dafny_operation_input
+
+
+class DafnyResponse(Wrappers.Result):
+ def __init__(self):
+ super().__init__(self)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_aws_sdk.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_aws_sdk.py
new file mode 100644
index 000000000..4eacf1895
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_aws_sdk.py
@@ -0,0 +1,1977 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_cryptography_internal_dynamodb.internaldafny.generated.ComAmazonawsDynamodbTypes import (
+ AttributeAction_ADD,
+ AttributeAction_DELETE,
+ AttributeAction_PUT,
+ AttributeValue_B,
+ AttributeValue_BOOL,
+ AttributeValue_BS,
+ AttributeValue_L,
+ AttributeValue_M,
+ AttributeValue_N,
+ AttributeValue_NS,
+ AttributeValue_NULL,
+ AttributeValue_S,
+ AttributeValue_SS,
+ BatchStatementErrorCodeEnum_AccessDenied,
+ BatchStatementErrorCodeEnum_ConditionalCheckFailed,
+ BatchStatementErrorCodeEnum_DuplicateItem,
+ BatchStatementErrorCodeEnum_InternalServerError,
+ BatchStatementErrorCodeEnum_ItemCollectionSizeLimitExceeded,
+ BatchStatementErrorCodeEnum_ProvisionedThroughputExceeded,
+ BatchStatementErrorCodeEnum_RequestLimitExceeded,
+ BatchStatementErrorCodeEnum_ResourceNotFound,
+ BatchStatementErrorCodeEnum_ThrottlingError,
+ BatchStatementErrorCodeEnum_TransactionConflict,
+ BatchStatementErrorCodeEnum_ValidationError,
+ ComparisonOperator_BEGINS__WITH,
+ ComparisonOperator_BETWEEN,
+ ComparisonOperator_CONTAINS,
+ ComparisonOperator_EQ,
+ ComparisonOperator_GE,
+ ComparisonOperator_GT,
+ ComparisonOperator_IN,
+ ComparisonOperator_LE,
+ ComparisonOperator_LT,
+ ComparisonOperator_NE,
+ ComparisonOperator_NOT__CONTAINS,
+ ComparisonOperator_NOT__NULL,
+ ComparisonOperator_NULL,
+ ConditionalOperator_AND,
+ ConditionalOperator_OR,
+ ReturnConsumedCapacity_INDEXES,
+ ReturnConsumedCapacity_NONE,
+ ReturnConsumedCapacity_TOTAL,
+ ReturnItemCollectionMetrics_NONE,
+ ReturnItemCollectionMetrics_SIZE,
+ ReturnValue_ALL__NEW,
+ ReturnValue_ALL__OLD,
+ ReturnValue_NONE,
+ ReturnValue_UPDATED__NEW,
+ ReturnValue_UPDATED__OLD,
+ ReturnValuesOnConditionCheckFailure_ALL__OLD,
+ ReturnValuesOnConditionCheckFailure_NONE,
+ Select_ALL__ATTRIBUTES,
+ Select_ALL__PROJECTED__ATTRIBUTES,
+ Select_COUNT,
+ Select_SPECIFIC__ATTRIBUTES,
+)
+import aws_cryptography_internal_dynamodb.internaldafny.generated.module_
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+
+
+def com_amazonaws_dynamodb_AttributeValue(dafny_input):
+ # Convert AttributeValue
+ if isinstance(dafny_input, AttributeValue_S):
+ AttributeValue_union_value = {
+ "S": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.S).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_N):
+ AttributeValue_union_value = {
+ "N": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.N).decode("utf-16-be")
+ }
+ elif isinstance(dafny_input, AttributeValue_B):
+ AttributeValue_union_value = {"B": bytes(dafny_input.B)}
+ elif isinstance(dafny_input, AttributeValue_SS):
+ AttributeValue_union_value = {
+ "SS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.SS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NS):
+ AttributeValue_union_value = {
+ "NS": [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.NS
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_BS):
+ AttributeValue_union_value = {"BS": [bytes(list_element) for list_element in dafny_input.BS]}
+ elif isinstance(dafny_input, AttributeValue_M):
+ AttributeValue_union_value = {
+ "M": {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.M.items
+ }
+ }
+ elif isinstance(dafny_input, AttributeValue_L):
+ AttributeValue_union_value = {
+ "L": [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.L
+ ]
+ }
+ elif isinstance(dafny_input, AttributeValue_NULL):
+ AttributeValue_union_value = {"NULL": dafny_input.NULL}
+ elif isinstance(dafny_input, AttributeValue_BOOL):
+ AttributeValue_union_value = {"BOOL": dafny_input.BOOL}
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return AttributeValue_union_value
+
+
+def com_amazonaws_dynamodb_ExpectedAttributeValue(dafny_input):
+ output = {}
+ if dafny_input.Value.is_Some:
+ output["Value"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ dafny_input.Value.value
+ )
+ )
+
+ if dafny_input.Exists.is_Some:
+ output["Exists"] = dafny_input.Exists.value
+
+ if dafny_input.ComparisonOperator.is_Some:
+ output["ComparisonOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ComparisonOperator(
+ dafny_input.ComparisonOperator.value
+ )
+ )
+
+ if dafny_input.AttributeValueList.is_Some:
+ output["AttributeValueList"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.AttributeValueList.value
+ ]
+
+ return output
+
+
+def com_amazonaws_dynamodb_ComparisonOperator(dafny_input):
+ # Convert ComparisonOperator
+ if isinstance(dafny_input, ComparisonOperator_EQ):
+ return "EQ"
+
+ elif isinstance(dafny_input, ComparisonOperator_NE):
+ return "NE"
+
+ elif isinstance(dafny_input, ComparisonOperator_IN):
+ return "IN"
+
+ elif isinstance(dafny_input, ComparisonOperator_LE):
+ return "LE"
+
+ elif isinstance(dafny_input, ComparisonOperator_LT):
+ return "LT"
+
+ elif isinstance(dafny_input, ComparisonOperator_GE):
+ return "GE"
+
+ elif isinstance(dafny_input, ComparisonOperator_GT):
+ return "GT"
+
+ elif isinstance(dafny_input, ComparisonOperator_BETWEEN):
+ return "BETWEEN"
+
+ elif isinstance(dafny_input, ComparisonOperator_NOT__NULL):
+ return "NOT_NULL"
+
+ elif isinstance(dafny_input, ComparisonOperator_NULL):
+ return "NULL"
+
+ elif isinstance(dafny_input, ComparisonOperator_CONTAINS):
+ return "CONTAINS"
+
+ elif isinstance(dafny_input, ComparisonOperator_NOT__CONTAINS):
+ return "NOT_CONTAINS"
+
+ elif isinstance(dafny_input, ComparisonOperator_BEGINS__WITH):
+ return "BEGINS_WITH"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_ReturnValue(dafny_input):
+ # Convert ReturnValue
+ if isinstance(dafny_input, ReturnValue_NONE):
+ return "NONE"
+
+ elif isinstance(dafny_input, ReturnValue_ALL__OLD):
+ return "ALL_OLD"
+
+ elif isinstance(dafny_input, ReturnValue_UPDATED__OLD):
+ return "UPDATED_OLD"
+
+ elif isinstance(dafny_input, ReturnValue_ALL__NEW):
+ return "ALL_NEW"
+
+ elif isinstance(dafny_input, ReturnValue_UPDATED__NEW):
+ return "UPDATED_NEW"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_ReturnConsumedCapacity(dafny_input):
+ # Convert ReturnConsumedCapacity
+ if isinstance(dafny_input, ReturnConsumedCapacity_INDEXES):
+ return "INDEXES"
+
+ elif isinstance(dafny_input, ReturnConsumedCapacity_TOTAL):
+ return "TOTAL"
+
+ elif isinstance(dafny_input, ReturnConsumedCapacity_NONE):
+ return "NONE"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_ReturnItemCollectionMetrics(dafny_input):
+ # Convert ReturnItemCollectionMetrics
+ if isinstance(dafny_input, ReturnItemCollectionMetrics_SIZE):
+ return "SIZE"
+
+ elif isinstance(dafny_input, ReturnItemCollectionMetrics_NONE):
+ return "NONE"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_ConditionalOperator(dafny_input):
+ # Convert ConditionalOperator
+ if isinstance(dafny_input, ConditionalOperator_AND):
+ return "AND"
+
+ elif isinstance(dafny_input, ConditionalOperator_OR):
+ return "OR"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(dafny_input):
+ # Convert ReturnValuesOnConditionCheckFailure
+ if isinstance(dafny_input, ReturnValuesOnConditionCheckFailure_ALL__OLD):
+ return "ALL_OLD"
+
+ elif isinstance(dafny_input, ReturnValuesOnConditionCheckFailure_NONE):
+ return "NONE"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_PutItemInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.items
+ }
+ if dafny_input.Expected.is_Some:
+ output["Expected"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Expected.value.items
+ }
+
+ if dafny_input.ReturnValues.is_Some:
+ output["ReturnValues"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValue(
+ dafny_input.ReturnValues.value
+ )
+ )
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ReturnItemCollectionMetrics.is_Some:
+ output["ReturnItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ dafny_input.ReturnItemCollectionMetrics.value
+ )
+ )
+
+ if dafny_input.ConditionalOperator.is_Some:
+ output["ConditionalOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
+ dafny_input.ConditionalOperator.value
+ )
+ )
+
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ConsumedCapacity(dafny_input):
+ output = {}
+ if dafny_input.TableName.is_Some:
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.CapacityUnits.is_Some:
+ output["CapacityUnits"] = dafny_input.CapacityUnits.value
+
+ if dafny_input.ReadCapacityUnits.is_Some:
+ output["ReadCapacityUnits"] = dafny_input.ReadCapacityUnits.value
+
+ if dafny_input.WriteCapacityUnits.is_Some:
+ output["WriteCapacityUnits"] = dafny_input.WriteCapacityUnits.value
+
+ if dafny_input.Table.is_Some:
+ output["Table"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Capacity(
+ dafny_input.Table.value
+ )
+ )
+
+ if dafny_input.LocalSecondaryIndexes.is_Some:
+ output["LocalSecondaryIndexes"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Capacity(
+ value
+ )
+ for (key, value) in dafny_input.LocalSecondaryIndexes.value.items
+ }
+
+ if dafny_input.GlobalSecondaryIndexes.is_Some:
+ output["GlobalSecondaryIndexes"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Capacity(
+ value
+ )
+ for (key, value) in dafny_input.GlobalSecondaryIndexes.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_Capacity(dafny_input):
+ output = {}
+ if dafny_input.ReadCapacityUnits.is_Some:
+ output["ReadCapacityUnits"] = dafny_input.ReadCapacityUnits.value
+
+ if dafny_input.WriteCapacityUnits.is_Some:
+ output["WriteCapacityUnits"] = dafny_input.WriteCapacityUnits.value
+
+ if dafny_input.CapacityUnits.is_Some:
+ output["CapacityUnits"] = dafny_input.CapacityUnits.value
+
+ return output
+
+
+def com_amazonaws_dynamodb_ItemCollectionMetrics(dafny_input):
+ output = {}
+ if dafny_input.ItemCollectionKey.is_Some:
+ output["ItemCollectionKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ItemCollectionKey.value.items
+ }
+
+ if dafny_input.SizeEstimateRangeGB.is_Some:
+ output["SizeEstimateRangeGB"] = [list_element for list_element in dafny_input.SizeEstimateRangeGB.value]
+
+ return output
+
+
+def com_amazonaws_dynamodb_PutItemOutput(dafny_input):
+ output = {}
+ if dafny_input.Attributes.is_Some:
+ output["Attributes"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Attributes.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ItemCollectionMetrics.is_Some:
+ output["ItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ dafny_input.ItemCollectionMetrics.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_GetItemInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ if dafny_input.AttributesToGet.is_Some:
+ output["AttributesToGet"] = [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.AttributesToGet.value
+ ]
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ProjectionExpression.is_Some:
+ output["ProjectionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_GetItemOutput(dafny_input):
+ output = {}
+ if dafny_input.Item.is_Some:
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_WriteRequest(dafny_input):
+ output = {}
+ if dafny_input.PutRequest.is_Some:
+ output["PutRequest"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutRequest(
+ dafny_input.PutRequest.value
+ )
+ )
+
+ if dafny_input.DeleteRequest.is_Some:
+ output["DeleteRequest"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteRequest(
+ dafny_input.DeleteRequest.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_PutRequest(dafny_input):
+ output = {}
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.items
+ }
+ return output
+
+
+def com_amazonaws_dynamodb_DeleteRequest(dafny_input):
+ output = {}
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ return output
+
+
+def com_amazonaws_dynamodb_BatchWriteItemInput(dafny_input):
+ output = {}
+ output["RequestItems"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode("utf-16-be"): [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_WriteRequest(
+ list_element
+ )
+ for list_element in value
+ ]
+ for (key, value) in dafny_input.RequestItems.items
+ }
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ReturnItemCollectionMetrics.is_Some:
+ output["ReturnItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ dafny_input.ReturnItemCollectionMetrics.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchWriteItemOutput(dafny_input):
+ output = {}
+ if dafny_input.UnprocessedItems.is_Some:
+ output["UnprocessedItems"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode("utf-16-be"): [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_WriteRequest(
+ list_element
+ )
+ for list_element in value
+ ]
+ for (key, value) in dafny_input.UnprocessedItems.value.items
+ }
+
+ if dafny_input.ItemCollectionMetrics.is_Some:
+ output["ItemCollectionMetrics"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode("utf-16-be"): [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ list_element
+ )
+ for list_element in value
+ ]
+ for (key, value) in dafny_input.ItemCollectionMetrics.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ return output
+
+
+def com_amazonaws_dynamodb_KeysAndAttributes(dafny_input):
+ output = {}
+ output["Keys"] = [
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items
+ }
+ for list_element in dafny_input.Keys
+ ]
+ if dafny_input.AttributesToGet.is_Some:
+ output["AttributesToGet"] = [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.AttributesToGet.value
+ ]
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ if dafny_input.ProjectionExpression.is_Some:
+ output["ProjectionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchGetItemInput(dafny_input):
+ output = {}
+ output["RequestItems"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_KeysAndAttributes(
+ value
+ )
+ for (key, value) in dafny_input.RequestItems.items
+ }
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchGetItemOutput(dafny_input):
+ output = {}
+ if dafny_input.Responses.is_Some:
+ output["Responses"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode("utf-16-be"): [
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items
+ }
+ for list_element in value
+ ]
+ for (key, value) in dafny_input.Responses.value.items
+ }
+
+ if dafny_input.UnprocessedKeys.is_Some:
+ output["UnprocessedKeys"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_KeysAndAttributes(
+ value
+ )
+ for (key, value) in dafny_input.UnprocessedKeys.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ return output
+
+
+def com_amazonaws_dynamodb_Select(dafny_input):
+ # Convert Select
+ if isinstance(dafny_input, Select_ALL__ATTRIBUTES):
+ return "ALL_ATTRIBUTES"
+
+ elif isinstance(dafny_input, Select_ALL__PROJECTED__ATTRIBUTES):
+ return "ALL_PROJECTED_ATTRIBUTES"
+
+ elif isinstance(dafny_input, Select_SPECIFIC__ATTRIBUTES):
+ return "SPECIFIC_ATTRIBUTES"
+
+ elif isinstance(dafny_input, Select_COUNT):
+ return "COUNT"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_Condition(dafny_input):
+ output = {}
+ if dafny_input.AttributeValueList.is_Some:
+ output["AttributeValueList"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.AttributeValueList.value
+ ]
+
+ output["ComparisonOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ComparisonOperator(
+ dafny_input.ComparisonOperator
+ )
+ )
+ return output
+
+
+def com_amazonaws_dynamodb_ScanInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.IndexName.is_Some:
+ output["IndexName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.IndexName.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.AttributesToGet.is_Some:
+ output["AttributesToGet"] = [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.AttributesToGet.value
+ ]
+
+ if dafny_input.Limit.is_Some:
+ output["Limit"] = dafny_input.Limit.value
+
+ if dafny_input.Select.is_Some:
+ output["Select"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Select(
+ dafny_input.Select.value
+ )
+ )
+
+ if dafny_input.ScanFilter.is_Some:
+ output["ScanFilter"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in dafny_input.ScanFilter.value.items
+ }
+
+ if dafny_input.ConditionalOperator.is_Some:
+ output["ConditionalOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
+ dafny_input.ConditionalOperator.value
+ )
+ )
+
+ if dafny_input.ExclusiveStartKey.is_Some:
+ output["ExclusiveStartKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExclusiveStartKey.value.items
+ }
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.TotalSegments.is_Some:
+ output["TotalSegments"] = dafny_input.TotalSegments.value
+
+ if dafny_input.Segment.is_Some:
+ output["Segment"] = dafny_input.Segment.value
+
+ if dafny_input.ProjectionExpression.is_Some:
+ output["ProjectionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.FilterExpression.is_Some:
+ output["FilterExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.FilterExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ return output
+
+
+def com_amazonaws_dynamodb_ScanOutput(dafny_input):
+ output = {}
+ if dafny_input.Items.is_Some:
+ output["Items"] = [
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items
+ }
+ for list_element in dafny_input.Items.value
+ ]
+
+ if dafny_input.Count.is_Some:
+ output["Count"] = dafny_input.Count.value
+
+ if dafny_input.ScannedCount.is_Some:
+ output["ScannedCount"] = dafny_input.ScannedCount.value
+
+ if dafny_input.LastEvaluatedKey.is_Some:
+ output["LastEvaluatedKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.LastEvaluatedKey.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_QueryInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.IndexName.is_Some:
+ output["IndexName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.IndexName.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.Select.is_Some:
+ output["Select"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Select(
+ dafny_input.Select.value
+ )
+ )
+
+ if dafny_input.AttributesToGet.is_Some:
+ output["AttributesToGet"] = [
+ b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
+ for list_element in dafny_input.AttributesToGet.value
+ ]
+
+ if dafny_input.Limit.is_Some:
+ output["Limit"] = dafny_input.Limit.value
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ if dafny_input.KeyConditions.is_Some:
+ output["KeyConditions"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in dafny_input.KeyConditions.value.items
+ }
+
+ if dafny_input.QueryFilter.is_Some:
+ output["QueryFilter"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Condition(
+ value
+ )
+ for (key, value) in dafny_input.QueryFilter.value.items
+ }
+
+ if dafny_input.ConditionalOperator.is_Some:
+ output["ConditionalOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
+ dafny_input.ConditionalOperator.value
+ )
+ )
+
+ if dafny_input.ScanIndexForward.is_Some:
+ output["ScanIndexForward"] = dafny_input.ScanIndexForward.value
+
+ if dafny_input.ExclusiveStartKey.is_Some:
+ output["ExclusiveStartKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExclusiveStartKey.value.items
+ }
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ProjectionExpression.is_Some:
+ output["ProjectionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.FilterExpression.is_Some:
+ output["FilterExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.FilterExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.KeyConditionExpression.is_Some:
+ output["KeyConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.KeyConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_QueryOutput(dafny_input):
+ output = {}
+ if dafny_input.Items.is_Some:
+ output["Items"] = [
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items
+ }
+ for list_element in dafny_input.Items.value
+ ]
+
+ if dafny_input.Count.is_Some:
+ output["Count"] = dafny_input.Count.value
+
+ if dafny_input.ScannedCount.is_Some:
+ output["ScannedCount"] = dafny_input.ScannedCount.value
+
+ if dafny_input.LastEvaluatedKey.is_Some:
+ output["LastEvaluatedKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.LastEvaluatedKey.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactWriteItem(dafny_input):
+ output = {}
+ if dafny_input.ConditionCheck.is_Some:
+ output["ConditionCheck"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionCheck(
+ dafny_input.ConditionCheck.value
+ )
+ )
+
+ if dafny_input.Put.is_Some:
+ output["Put"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Put(
+ dafny_input.Put.value
+ )
+ )
+
+ if dafny_input.Delete.is_Some:
+ output["Delete"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Delete(
+ dafny_input.Delete.value
+ )
+ )
+
+ if dafny_input.Update.is_Some:
+ output["Update"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Update(
+ dafny_input.Update.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ConditionCheck(dafny_input):
+ output = {}
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ output["ConditionExpression"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression).decode(
+ "utf-16-be"
+ )
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_Put(dafny_input):
+ output = {}
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.items
+ }
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_Delete(dafny_input):
+ output = {}
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_Update(dafny_input):
+ output = {}
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ output["UpdateExpression"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.UpdateExpression).decode(
+ "utf-16-be"
+ )
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactWriteItemsInput(dafny_input):
+ output = {}
+ output["TransactItems"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItem(
+ list_element
+ )
+ for list_element in dafny_input.TransactItems
+ ]
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ReturnItemCollectionMetrics.is_Some:
+ output["ReturnItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ dafny_input.ReturnItemCollectionMetrics.value
+ )
+ )
+
+ if dafny_input.ClientRequestToken.is_Some:
+ output["ClientRequestToken"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ClientRequestToken.value
+ ).decode("utf-16-be")
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactWriteItemsOutput(dafny_input):
+ output = {}
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ if dafny_input.ItemCollectionMetrics.is_Some:
+ output["ItemCollectionMetrics"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode("utf-16-be"): [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ list_element
+ )
+ for list_element in value
+ ]
+ for (key, value) in dafny_input.ItemCollectionMetrics.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_AttributeValueUpdate(dafny_input):
+ output = {}
+ if dafny_input.Value.is_Some:
+ output["Value"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ dafny_input.Value.value
+ )
+ )
+
+ if dafny_input.Action.is_Some:
+ output["Action"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeAction(
+ dafny_input.Action.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_AttributeAction(dafny_input):
+ # Convert AttributeAction
+ if isinstance(dafny_input, AttributeAction_ADD):
+ return "ADD"
+
+ elif isinstance(dafny_input, AttributeAction_PUT):
+ return "PUT"
+
+ elif isinstance(dafny_input, AttributeAction_DELETE):
+ return "DELETE"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_UpdateItemInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ if dafny_input.AttributeUpdates.is_Some:
+ output["AttributeUpdates"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValueUpdate(
+ value
+ )
+ for (key, value) in dafny_input.AttributeUpdates.value.items
+ }
+
+ if dafny_input.Expected.is_Some:
+ output["Expected"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Expected.value.items
+ }
+
+ if dafny_input.ConditionalOperator.is_Some:
+ output["ConditionalOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
+ dafny_input.ConditionalOperator.value
+ )
+ )
+
+ if dafny_input.ReturnValues.is_Some:
+ output["ReturnValues"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValue(
+ dafny_input.ReturnValues.value
+ )
+ )
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ReturnItemCollectionMetrics.is_Some:
+ output["ReturnItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ dafny_input.ReturnItemCollectionMetrics.value
+ )
+ )
+
+ if dafny_input.UpdateExpression.is_Some:
+ output["UpdateExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.UpdateExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_UpdateItemOutput(dafny_input):
+ output = {}
+ if dafny_input.Attributes.is_Some:
+ output["Attributes"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Attributes.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ItemCollectionMetrics.is_Some:
+ output["ItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ dafny_input.ItemCollectionMetrics.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_DeleteItemInput(dafny_input):
+ output = {}
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ if dafny_input.Expected.is_Some:
+ output["Expected"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExpectedAttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Expected.value.items
+ }
+
+ if dafny_input.ConditionalOperator.is_Some:
+ output["ConditionalOperator"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
+ dafny_input.ConditionalOperator.value
+ )
+ )
+
+ if dafny_input.ReturnValues.is_Some:
+ output["ReturnValues"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValue(
+ dafny_input.ReturnValues.value
+ )
+ )
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ReturnItemCollectionMetrics.is_Some:
+ output["ReturnItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnItemCollectionMetrics(
+ dafny_input.ReturnItemCollectionMetrics.value
+ )
+ )
+
+ if dafny_input.ConditionExpression.is_Some:
+ output["ConditionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ConditionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ if dafny_input.ExpressionAttributeValues.is_Some:
+ output["ExpressionAttributeValues"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.ExpressionAttributeValues.value.items
+ }
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_DeleteItemOutput(dafny_input):
+ output = {}
+ if dafny_input.Attributes.is_Some:
+ output["Attributes"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Attributes.value.items
+ }
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.ItemCollectionMetrics.is_Some:
+ output["ItemCollectionMetrics"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemCollectionMetrics(
+ dafny_input.ItemCollectionMetrics.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactGetItem(dafny_input):
+ output = {}
+ output["Get"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Get(
+ dafny_input.Get
+ )
+ )
+ return output
+
+
+def com_amazonaws_dynamodb_Get(dafny_input):
+ output = {}
+ output["Key"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Key.items
+ }
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be")
+ if dafny_input.ProjectionExpression.is_Some:
+ output["ProjectionExpression"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ExpressionAttributeNames.is_Some:
+ output["ExpressionAttributeNames"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.ExpressionAttributeNames.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactGetItemsInput(dafny_input):
+ output = {}
+ output["TransactItems"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItem(
+ list_element
+ )
+ for list_element in dafny_input.TransactItems
+ ]
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ItemResponse(dafny_input):
+ output = {}
+ if dafny_input.Item.is_Some:
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_TransactGetItemsOutput(dafny_input):
+ output = {}
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ if dafny_input.Responses.is_Some:
+ output["Responses"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemResponse(
+ list_element
+ )
+ for list_element in dafny_input.Responses.value
+ ]
+
+ return output
+
+
+def com_amazonaws_dynamodb_ExecuteStatementInput(dafny_input):
+ output = {}
+ output["Statement"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.Statement).decode("utf-16-be")
+ if dafny_input.Parameters.is_Some:
+ output["Parameters"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.Parameters.value
+ ]
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ if dafny_input.NextToken.is_Some:
+ output["NextToken"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.NextToken.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.Limit.is_Some:
+ output["Limit"] = dafny_input.Limit.value
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ExecuteStatementOutput(dafny_input):
+ output = {}
+ if dafny_input.Items.is_Some:
+ output["Items"] = [
+ {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in list_element.items
+ }
+ for list_element in dafny_input.Items.value
+ ]
+
+ if dafny_input.NextToken.is_Some:
+ output["NextToken"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.NextToken.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ dafny_input.ConsumedCapacity.value
+ )
+ )
+
+ if dafny_input.LastEvaluatedKey.is_Some:
+ output["LastEvaluatedKey"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.LastEvaluatedKey.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchStatementRequest(dafny_input):
+ output = {}
+ output["Statement"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.Statement).decode("utf-16-be")
+ if dafny_input.Parameters.is_Some:
+ output["Parameters"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.Parameters.value
+ ]
+
+ if dafny_input.ConsistentRead.is_Some:
+ output["ConsistentRead"] = dafny_input.ConsistentRead.value
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchExecuteStatementInput(dafny_input):
+ output = {}
+ output["Statements"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchStatementRequest(
+ list_element
+ )
+ for list_element in dafny_input.Statements
+ ]
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchStatementResponse(dafny_input):
+ output = {}
+ if dafny_input.Error.is_Some:
+ output["Error"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchStatementError(
+ dafny_input.Error.value
+ )
+ )
+
+ if dafny_input.TableName.is_Some:
+ output["TableName"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName.value).decode(
+ "utf-16-be"
+ )
+
+ if dafny_input.Item.is_Some:
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchStatementError(dafny_input):
+ output = {}
+ if dafny_input.Code.is_Some:
+ output["Code"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchStatementErrorCodeEnum(
+ dafny_input.Code.value
+ )
+ )
+
+ if dafny_input.Message.is_Some:
+ output["Message"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.Message.value).decode("utf-16-be")
+
+ if dafny_input.Item.is_Some:
+ output["Item"] = {
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.value.items
+ }
+
+ return output
+
+
+def com_amazonaws_dynamodb_BatchStatementErrorCodeEnum(dafny_input):
+ # Convert BatchStatementErrorCodeEnum
+ if isinstance(dafny_input, BatchStatementErrorCodeEnum_ConditionalCheckFailed):
+ return "ConditionalCheckFailed"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_ItemCollectionSizeLimitExceeded):
+ return "ItemCollectionSizeLimitExceeded"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_RequestLimitExceeded):
+ return "RequestLimitExceeded"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_ValidationError):
+ return "ValidationError"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_ProvisionedThroughputExceeded):
+ return "ProvisionedThroughputExceeded"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_TransactionConflict):
+ return "TransactionConflict"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_ThrottlingError):
+ return "ThrottlingError"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_InternalServerError):
+ return "InternalServerError"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_ResourceNotFound):
+ return "ResourceNotFound"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_AccessDenied):
+ return "AccessDenied"
+
+ elif isinstance(dafny_input, BatchStatementErrorCodeEnum_DuplicateItem):
+ return "DuplicateItem"
+
+ else:
+ raise ValueError("No recognized enum value in enum type: " + dafny_input)
+
+
+def com_amazonaws_dynamodb_BatchExecuteStatementOutput(dafny_input):
+ output = {}
+ if dafny_input.Responses.is_Some:
+ output["Responses"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchStatementResponse(
+ list_element
+ )
+ for list_element in dafny_input.Responses.value
+ ]
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ return output
+
+
+def com_amazonaws_dynamodb_ParameterizedStatement(dafny_input):
+ output = {}
+ output["Statement"] = b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.Statement).decode("utf-16-be")
+ if dafny_input.Parameters.is_Some:
+ output["Parameters"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ list_element
+ )
+ for list_element in dafny_input.Parameters.value
+ ]
+
+ if dafny_input.ReturnValuesOnConditionCheckFailure.is_Some:
+ output["ReturnValuesOnConditionCheckFailure"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnValuesOnConditionCheckFailure(
+ dafny_input.ReturnValuesOnConditionCheckFailure.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ExecuteTransactionInput(dafny_input):
+ output = {}
+ output["TransactStatements"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ParameterizedStatement(
+ list_element
+ )
+ for list_element in dafny_input.TransactStatements
+ ]
+ if dafny_input.ClientRequestToken.is_Some:
+ output["ClientRequestToken"] = b"".join(
+ ord(c).to_bytes(2, "big") for c in dafny_input.ClientRequestToken.value
+ ).decode("utf-16-be")
+
+ if dafny_input.ReturnConsumedCapacity.is_Some:
+ output["ReturnConsumedCapacity"] = (
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
+ dafny_input.ReturnConsumedCapacity.value
+ )
+ )
+
+ return output
+
+
+def com_amazonaws_dynamodb_ExecuteTransactionOutput(dafny_input):
+ output = {}
+ if dafny_input.Responses.is_Some:
+ output["Responses"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ItemResponse(
+ list_element
+ )
+ for list_element in dafny_input.Responses.value
+ ]
+
+ if dafny_input.ConsumedCapacity.is_Some:
+ output["ConsumedCapacity"] = [
+ aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConsumedCapacity(
+ list_element
+ )
+ for list_element in dafny_input.ConsumedCapacity.value
+ ]
+
+ return output
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_smithy.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_smithy.py
new file mode 100644
index 000000000..11826b3ec
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/dafny_to_smithy.py
@@ -0,0 +1,641 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.PutItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.PutItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.GetItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_GetItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.GetItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_GetItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_GetItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchWriteItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchWriteItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchWriteItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchWriteItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchWriteItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchGetItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchGetItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchGetItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchGetItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchGetItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ScanInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ScanInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ScanOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ScanOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ScanInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.QueryInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_QueryInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.QueryOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_QueryOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_QueryInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactWriteItemsInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactWriteItemsOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItemsOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.UpdateItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_UpdateItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.UpdateItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_UpdateItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_UpdateItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.DeleteItemInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteItemInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.DeleteItemOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteItemOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteItemInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactGetItemsInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItemsInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactGetItemsOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItemsOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItemsInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteStatementInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteStatementInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteStatementOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteStatementOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteStatementInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchExecuteStatementInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchExecuteStatementOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchExecuteStatementOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteTransactionInputTransformInput(
+ sdk_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ dafny_input.sdkInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteTransactionOutputTransformInput(
+ sdk_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteTransactionOutput(
+ dafny_input.sdkOutput
+ ),
+ original_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ dafny_input.originalInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ResolveAttributesInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.TableName).decode("utf-16-be"),
+ item={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in dafny_input.Item.items
+ },
+ version=(dafny_input.Version.value) if (dafny_input.Version.is_Some) else None,
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.PutItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.PutItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_PutItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.GetItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_GetItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.GetItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_GetItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchWriteItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchWriteItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchWriteItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchWriteItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchGetItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchGetItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchGetItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchGetItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ScanInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ScanInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ScanOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ScanOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.QueryInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_QueryInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.QueryOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_QueryOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactWriteItemsInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactWriteItemsOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactWriteItemsOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.UpdateItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_UpdateItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.UpdateItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_UpdateItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.DeleteItemInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteItemInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.DeleteItemOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_DeleteItemOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactGetItemsInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItemsInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.TransactGetItemsOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_TransactGetItemsOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteStatementInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteStatementInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteStatementOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteStatementOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchExecuteStatementInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.BatchExecuteStatementOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_BatchExecuteStatementOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteTransactionInputTransformOutput(
+ transformed_input=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ dafny_input.transformedInput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ExecuteTransactionOutputTransformOutput(
+ transformed_output=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ExecuteTransactionOutput(
+ dafny_input.transformedOutput
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models.ResolveAttributesOutput(
+ virtual_fields={
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.VirtualFields.items
+ },
+ compound_beacons={
+ b"".join(ord(c).to_bytes(2, "big") for c in key)
+ .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
+ .decode("utf-16-be")
+ for (key, value) in dafny_input.CompoundBeacons.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_AwsCryptographicMaterialProvidersReference(
+ dafny_input,
+):
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.client import (
+ AwsCryptographicMaterialProviders,
+ )
+
+ return AwsCryptographicMaterialProviders(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DynamoDbEncryptionReference(
+ dafny_input,
+):
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.client import (
+ DynamoDbEncryption,
+ )
+
+ return DynamoDbEncryption(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DynamoDbItemEncryptorReference(
+ dafny_input,
+):
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.client import (
+ DynamoDbItemEncryptor,
+ )
+
+ return DynamoDbItemEncryptor(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_StructuredEncryptionReference(
+ dafny_input,
+):
+ from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.client import (
+ StructuredEncryption,
+ )
+
+ return StructuredEncryption(config=None, dafny_client=dafny_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/deserialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/deserialize.py
new file mode 100644
index 000000000..59bc7ba5d
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/deserialize.py
@@ -0,0 +1,350 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes import (
+ BatchExecuteStatementInputTransformOutput_BatchExecuteStatementInputTransformOutput as DafnyBatchExecuteStatementInputTransformOutput,
+ BatchExecuteStatementOutputTransformOutput_BatchExecuteStatementOutputTransformOutput as DafnyBatchExecuteStatementOutputTransformOutput,
+ BatchGetItemInputTransformOutput_BatchGetItemInputTransformOutput as DafnyBatchGetItemInputTransformOutput,
+ BatchGetItemOutputTransformOutput_BatchGetItemOutputTransformOutput as DafnyBatchGetItemOutputTransformOutput,
+ BatchWriteItemInputTransformOutput_BatchWriteItemInputTransformOutput as DafnyBatchWriteItemInputTransformOutput,
+ BatchWriteItemOutputTransformOutput_BatchWriteItemOutputTransformOutput as DafnyBatchWriteItemOutputTransformOutput,
+ DeleteItemInputTransformOutput_DeleteItemInputTransformOutput as DafnyDeleteItemInputTransformOutput,
+ DeleteItemOutputTransformOutput_DeleteItemOutputTransformOutput as DafnyDeleteItemOutputTransformOutput,
+ Error,
+ Error_DynamoDbEncryptionTransformsException,
+ ExecuteStatementInputTransformOutput_ExecuteStatementInputTransformOutput as DafnyExecuteStatementInputTransformOutput,
+ ExecuteStatementOutputTransformOutput_ExecuteStatementOutputTransformOutput as DafnyExecuteStatementOutputTransformOutput,
+ ExecuteTransactionInputTransformOutput_ExecuteTransactionInputTransformOutput as DafnyExecuteTransactionInputTransformOutput,
+ ExecuteTransactionOutputTransformOutput_ExecuteTransactionOutputTransformOutput as DafnyExecuteTransactionOutputTransformOutput,
+ GetItemInputTransformOutput_GetItemInputTransformOutput as DafnyGetItemInputTransformOutput,
+ GetItemOutputTransformOutput_GetItemOutputTransformOutput as DafnyGetItemOutputTransformOutput,
+ PutItemInputTransformOutput_PutItemInputTransformOutput as DafnyPutItemInputTransformOutput,
+ PutItemOutputTransformOutput_PutItemOutputTransformOutput as DafnyPutItemOutputTransformOutput,
+ QueryInputTransformOutput_QueryInputTransformOutput as DafnyQueryInputTransformOutput,
+ QueryOutputTransformOutput_QueryOutputTransformOutput as DafnyQueryOutputTransformOutput,
+ ResolveAttributesOutput_ResolveAttributesOutput as DafnyResolveAttributesOutput,
+ ScanInputTransformOutput_ScanInputTransformOutput as DafnyScanInputTransformOutput,
+ ScanOutputTransformOutput_ScanOutputTransformOutput as DafnyScanOutputTransformOutput,
+ TransactGetItemsInputTransformOutput_TransactGetItemsInputTransformOutput as DafnyTransactGetItemsInputTransformOutput,
+ TransactGetItemsOutputTransformOutput_TransactGetItemsOutputTransformOutput as DafnyTransactGetItemsOutputTransformOutput,
+ TransactWriteItemsInputTransformOutput_TransactWriteItemsInputTransformOutput as DafnyTransactWriteItemsInputTransformOutput,
+ TransactWriteItemsOutputTransformOutput_TransactWriteItemsOutputTransformOutput as DafnyTransactWriteItemsOutputTransformOutput,
+ UpdateItemInputTransformOutput_UpdateItemInputTransformOutput as DafnyUpdateItemInputTransformOutput,
+ UpdateItemOutputTransformOutput_UpdateItemOutputTransformOutput as DafnyUpdateItemOutputTransformOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy
+from typing import Any
+
+from .dafny_protocol import DafnyResponse
+from .errors import (
+ AwsCryptographicMaterialProviders,
+ CollectionOfErrors,
+ ComAmazonawsDynamodb,
+ DynamoDbEncryption,
+ DynamoDbEncryptionTransformsException,
+ DynamoDbItemEncryptor,
+ OpaqueError,
+ ServiceError,
+ StructuredEncryption,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.deserialize import (
+ _deserialize_error as aws_cryptography_materialproviders_deserialize_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+
+from ..aws_cryptography_dbencryptionsdk_dynamodb.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error,
+)
+from ..aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_deserialize_error,
+)
+from ..aws_cryptography_dbencryptionsdk_structuredencryption.deserialize import (
+ _deserialize_error as aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error,
+)
+from .config import Config
+
+
+def _deserialize_put_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_put_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_get_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_get_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_write_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_write_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_get_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_get_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_scan_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_scan_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_query_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_query_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_transact_write_items_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_transact_write_items_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_update_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_update_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_delete_item_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_delete_item_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_transact_get_items_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_transact_get_items_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_execute_statement_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_execute_statement_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_execute_statement_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_batch_execute_statement_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_execute_transaction_input_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_execute_transaction_output_transform(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformOutput(
+ input.value
+ )
+
+
+def _deserialize_resolve_attributes(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesOutput(
+ input.value
+ )
+
+
+def _deserialize_error(error: Error) -> ServiceError:
+ if error.is_Opaque:
+ return OpaqueError(obj=error.obj)
+ elif error.is_OpaqueWithText:
+ return OpaqueErrorWithText(obj=error.obj, obj_message=error.objMessage)
+ elif error.is_CollectionOfErrors:
+ return CollectionOfErrors(
+ message=_dafny.string_of(error.message),
+ list=[_deserialize_error(dafny_e) for dafny_e in error.list],
+ )
+ elif error.is_DynamoDbEncryptionTransformsException:
+ return DynamoDbEncryptionTransformsException(message=_dafny.string_of(error.message))
+ elif error.is_AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptor:
+ return DynamoDbItemEncryptor(
+ aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_deserialize_error(
+ error.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptor
+ )
+ )
+ elif error.is_AwsCryptographyDbEncryptionSdkStructuredEncryption:
+ return StructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_deserialize_error(
+ error.AwsCryptographyDbEncryptionSdkStructuredEncryption
+ )
+ )
+ elif error.is_AwsCryptographyDbEncryptionSdkDynamoDb:
+ return DynamoDbEncryption(
+ aws_cryptography_dbencryptionsdk_dynamodb_deserialize_error(error.AwsCryptographyDbEncryptionSdkDynamoDb)
+ )
+ elif error.is_AwsCryptographyMaterialProviders:
+ return AwsCryptographicMaterialProviders(
+ aws_cryptography_materialproviders_deserialize_error(error.AwsCryptographyMaterialProviders)
+ )
+ elif error.is_ComAmazonawsDynamodb:
+ return ComAmazonawsDynamodb(message=_dafny.string_of(error.ComAmazonawsDynamodb.message))
+ else:
+ return OpaqueError(obj=error)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/errors.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/errors.py
new file mode 100644
index 000000000..bfb2b7726
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/errors.py
@@ -0,0 +1,337 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_materialproviders_smithy_error_to_dafny_error,
+)
+from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.shim import (
+ _sdk_error_to_dafny_error as com_amazonaws_dynamodb_sdk_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_dynamodb_smithy_error_to_dafny_error,
+)
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.errors
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error,
+)
+from typing import Any, Dict, Generic, List, Literal, TypeVar
+
+
+class ServiceError(Exception):
+ """Base error for all errors in the service."""
+
+ pass
+
+
+T = TypeVar("T")
+
+
+class ApiError(ServiceError, Generic[T]):
+ """Base error for all api errors in the service."""
+
+ code: T
+
+ def __init__(self, message: str):
+ super().__init__(message)
+ self.message = message
+
+
+class UnknownApiError(ApiError[Literal["Unknown"]]):
+ """Error representing any unknown api errors."""
+
+ code: Literal["Unknown"] = "Unknown"
+
+
+class DynamoDbEncryptionTransformsException(ApiError[Literal["DynamoDbEncryptionTransformsException"]]):
+ code: Literal["DynamoDbEncryptionTransformsException"] = "DynamoDbEncryptionTransformsException"
+ message: str
+
+ def __init__(
+ self,
+ *,
+ message: str,
+ ):
+ super().__init__(message)
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DynamoDbEncryptionTransformsException to a
+ dictionary."""
+ return {
+ "message": self.message,
+ "code": self.code,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DynamoDbEncryptionTransformsException":
+ """Creates a DynamoDbEncryptionTransformsException from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ }
+
+ return DynamoDbEncryptionTransformsException(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DynamoDbEncryptionTransformsException("
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DynamoDbEncryptionTransformsException):
+ return False
+ attributes: list[str] = [
+ "message",
+ "message",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DynamoDbEncryptionTransformsException(ApiError[Literal["DynamoDbEncryptionTransformsException"]]):
+ code: Literal["DynamoDbEncryptionTransformsException"] = "DynamoDbEncryptionTransformsException"
+ message: str
+
+
+class ComAmazonawsDynamodb(ApiError[Literal["ComAmazonawsDynamodb"]]):
+ ComAmazonawsDynamodb: Any
+
+
+class DynamoDbEncryption(ApiError[Literal["DynamoDbEncryption"]]):
+ DynamoDbEncryption: Any
+
+
+class DynamoDbItemEncryptor(ApiError[Literal["DynamoDbItemEncryptor"]]):
+ DynamoDbItemEncryptor: Any
+
+
+class StructuredEncryption(ApiError[Literal["StructuredEncryption"]]):
+ StructuredEncryption: Any
+
+
+class AwsCryptographicMaterialProviders(ApiError[Literal["AwsCryptographicMaterialProviders"]]):
+ AwsCryptographicMaterialProviders: Any
+
+
+class CollectionOfErrors(ApiError[Literal["CollectionOfErrors"]]):
+ code: Literal["CollectionOfErrors"] = "CollectionOfErrors"
+ message: str
+ list: List[ServiceError]
+
+ def __init__(self, *, message: str, list):
+ super().__init__(message)
+ self.list = list
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CollectionOfErrors to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "list": self.list,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CollectionOfErrors":
+ """Creates a CollectionOfErrors from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "list": d["list"]}
+
+ return CollectionOfErrors(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CollectionOfErrors("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"list={self.list}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CollectionOfErrors):
+ return False
+ if not (self.list == other.list):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueError(ApiError[Literal["OpaqueError"]]):
+ code: Literal["OpaqueError"] = "OpaqueError"
+ obj: Any # As an OpaqueError, type of obj is unknown
+
+ def __init__(self, *, obj):
+ super().__init__("")
+ self.obj = obj
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueError":
+ """Creates a OpaqueError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "obj": d["obj"]}
+
+ return OpaqueError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueWithTextError(ApiError[Literal["OpaqueWithTextError"]]):
+ code: Literal["OpaqueWithTextError"] = "OpaqueWithTextError"
+ obj: Any # As an OpaqueWithTextError, type of obj is unknown
+ obj_message: str # obj_message is a message representing the details of obj
+
+ def __init__(self, *, obj, obj_message):
+ super().__init__("")
+ self.obj = obj
+ self.obj_message = obj_message
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueWithTextError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ "obj_message": self.obj_message,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueWithTextError":
+ """Creates a OpaqueWithTextError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ "obj": d["obj"],
+ "obj_message": d["obj_message"],
+ }
+
+ return OpaqueWithTextError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueWithTextError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += f"obj_message={self.obj_message}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueWithTextError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _smithy_error_to_dafny_error(e: ServiceError):
+ """Converts the provided native Smithy-modeled error into the corresponding
+ Dafny error."""
+ if isinstance(
+ e,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.errors.DynamoDbEncryptionTransformsException,
+ ):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_DynamoDbEncryptionTransformsException(
+ message=_dafny.Seq(e.message)
+ )
+
+ if isinstance(e, ComAmazonawsDynamodb):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_ComAmazonawsDynamodb(
+ com_amazonaws_dynamodb_sdk_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, DynamoDbEncryption):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_AwsCryptographyDbEncryptionSdkDynamoDb(
+ aws_cryptography_dbencryptionsdk_dynamodb_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, DynamoDbItemEncryptor):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptor(
+ aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, StructuredEncryption):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_AwsCryptographyDbEncryptionSdkStructuredEncryption(
+ aws_cryptography_dbencryptionsdk_structuredencryption_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicMaterialProviders):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_AwsCryptographyMaterialProviders(
+ aws_cryptography_materialproviders_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, CollectionOfErrors):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_CollectionOfErrors(
+ message=_dafny.Seq(e.message),
+ list=_dafny.Seq(_smithy_error_to_dafny_error(native_err) for native_err in e.list),
+ )
+
+ if isinstance(e, OpaqueError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_Opaque(
+ obj=e.obj
+ )
+
+ if isinstance(e, OpaqueWithTextError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_OpaqueWithText(
+ obj=e.obj, objMessage=e.obj_message
+ )
+
+ else:
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes.Error_Opaque(
+ obj=e
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/models.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/models.py
new file mode 100644
index 000000000..3e7f1b86b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/models.py
@@ -0,0 +1,2565 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from typing import Any, Dict
+
+
+class ResolveAttributesOutput:
+ virtual_fields: dict[str, str]
+ compound_beacons: dict[str, str]
+
+ def __init__(
+ self,
+ *,
+ virtual_fields: dict[str, str],
+ compound_beacons: dict[str, str],
+ ):
+ """
+ :param virtual_fields: Full plaintext of all calculable virtual fields.
+ :param compound_beacons: Full plaintext of all calculable compound beacons.
+ """
+ self.virtual_fields = virtual_fields
+ self.compound_beacons = compound_beacons
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ResolveAttributesOutput to a dictionary."""
+ return {
+ "virtual_fields": self.virtual_fields,
+ "compound_beacons": self.compound_beacons,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ResolveAttributesOutput":
+ """Creates a ResolveAttributesOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "virtual_fields": d["virtual_fields"],
+ "compound_beacons": d["compound_beacons"],
+ }
+
+ return ResolveAttributesOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ResolveAttributesOutput("
+ if self.virtual_fields is not None:
+ result += f"virtual_fields={repr(self.virtual_fields)}, "
+
+ if self.compound_beacons is not None:
+ result += f"compound_beacons={repr(self.compound_beacons)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ResolveAttributesOutput):
+ return False
+ attributes: list[str] = [
+ "virtual_fields",
+ "compound_beacons",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ResolveAttributesInput:
+ table_name: str
+ item: "dict[str, dict[str, Any]]"
+ version: int
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ item: "dict[str, dict[str, Any]]",
+ version: int = 0,
+ ):
+ """
+ :param table_name: Use the config for this Table.
+ :param item: The Item to be examined.
+ :param version: The beacon version to use. Defaults to 'writeVersion'.
+ """
+ if (table_name is not None) and (len(table_name) < 3):
+ raise ValueError("The size of table_name must be greater than or equal to 3")
+
+ if (table_name is not None) and (len(table_name) > 255):
+ raise ValueError("The size of table_name must be less than or equal to 255")
+
+ self.table_name = table_name
+ self.item = item
+ if (version is not None) and (version < 1):
+ raise ValueError("version must be greater than or equal to 1")
+
+ self.version = version
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ResolveAttributesInput to a dictionary."""
+ d: Dict[str, Any] = {
+ "table_name": self.table_name,
+ "item": self.item,
+ }
+
+ if self.version is not None:
+ d["version"] = self.version
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ResolveAttributesInput":
+ """Creates a ResolveAttributesInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "item": d["item"],
+ }
+
+ if "version" in d:
+ kwargs["version"] = d["version"]
+
+ return ResolveAttributesInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ResolveAttributesInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.item is not None:
+ result += f"item={repr(self.item)}, "
+
+ if self.version is not None:
+ result += f"version={repr(self.version)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ResolveAttributesInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "item",
+ "version",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteStatementInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteStatementInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteStatementInputTransformInput":
+ """Creates a ExecuteStatementInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return ExecuteStatementInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteStatementInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteStatementInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteStatementInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteStatementInputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteStatementInputTransformOutput":
+ """Creates a ExecuteStatementInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return ExecuteStatementInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteStatementInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteStatementInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a GetItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetItemInputTransformInput":
+ """Creates a GetItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return GetItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a GetItem
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetItemInputTransformOutput":
+ """Creates a GetItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return GetItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a GetItem
+ operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetItemOutputTransformOutput":
+ """Creates a GetItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return GetItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchExecuteStatementInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchExecuteStatementInputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchExecuteStatementInputTransformInput":
+ """Creates a BatchExecuteStatementInputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return BatchExecuteStatementInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchExecuteStatementInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchExecuteStatementInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchExecuteStatementInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchExecuteStatementInputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchExecuteStatementInputTransformOutput":
+ """Creates a BatchExecuteStatementInputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return BatchExecuteStatementInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchExecuteStatementInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchExecuteStatementInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteTransactionInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteTransactionInputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteTransactionInputTransformInput":
+ """Creates a ExecuteTransactionInputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return ExecuteTransactionInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteTransactionInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteTransactionInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteTransactionInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteTransactionInputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteTransactionInputTransformOutput":
+ """Creates a ExecuteTransactionInputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return ExecuteTransactionInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteTransactionInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteTransactionInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteTransactionOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteTransactionOutputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteTransactionOutputTransformOutput":
+ """Creates a ExecuteTransactionOutputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return ExecuteTransactionOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteTransactionOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteTransactionOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactGetItemsOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactGetItemsOutputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactGetItemsOutputTransformOutput":
+ """Creates a TransactGetItemsOutputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return TransactGetItemsOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactGetItemsOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactGetItemsOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchGetItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a BatchGetItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchGetItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchGetItemInputTransformInput":
+ """Creates a BatchGetItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return BatchGetItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchGetItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchGetItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchGetItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a BatchGetItem
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchGetItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchGetItemInputTransformOutput":
+ """Creates a BatchGetItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return BatchGetItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchGetItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchGetItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactGetItemsInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactGetItemsInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactGetItemsInputTransformInput":
+ """Creates a TransactGetItemsInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return TransactGetItemsInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactGetItemsInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactGetItemsInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactGetItemsInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactGetItemsInputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactGetItemsInputTransformOutput":
+ """Creates a TransactGetItemsInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return TransactGetItemsInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactGetItemsInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactGetItemsInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactWriteItemsOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactWriteItemsOutputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactWriteItemsOutputTransformOutput":
+ """Creates a TransactWriteItemsOutputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return TransactWriteItemsOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactWriteItemsOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactWriteItemsOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class GetItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a GetItem
+ operation.
+ :param original_input: Represents the input of a GetItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the GetItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "GetItemOutputTransformInput":
+ """Creates a GetItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return GetItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "GetItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, GetItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DeleteItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a DeleteItem
+ operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DeleteItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DeleteItemOutputTransformOutput":
+ """Creates a DeleteItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return DeleteItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DeleteItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DeleteItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteStatementOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteStatementOutputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteStatementOutputTransformOutput":
+ """Creates a ExecuteStatementOutputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return ExecuteStatementOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteStatementOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteStatementOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PutItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a PutItem
+ operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the PutItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PutItemOutputTransformOutput":
+ """Creates a PutItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return PutItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "PutItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, PutItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class QueryOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a Query
+ operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the QueryOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "QueryOutputTransformOutput":
+ """Creates a QueryOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return QueryOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "QueryOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, QueryOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ScanOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a Scan
+ operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ScanOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ScanOutputTransformOutput":
+ """Creates a ScanOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return ScanOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ScanOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ScanOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class UpdateItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of an
+ UpdateItem operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the UpdateItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "UpdateItemOutputTransformOutput":
+ """Creates a UpdateItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return UpdateItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "UpdateItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, UpdateItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteTransactionOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteTransactionOutputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteTransactionOutputTransformInput":
+ """Creates a ExecuteTransactionOutputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return ExecuteTransactionOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteTransactionOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteTransactionOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchExecuteStatementOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchExecuteStatementOutputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchExecuteStatementOutputTransformOutput":
+ """Creates a BatchExecuteStatementOutputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return BatchExecuteStatementOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchExecuteStatementOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchExecuteStatementOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchGetItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a
+ BatchGetItem operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchGetItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchGetItemOutputTransformOutput":
+ """Creates a BatchGetItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return BatchGetItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchGetItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchGetItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactGetItemsOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactGetItemsOutputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactGetItemsOutputTransformInput":
+ """Creates a TransactGetItemsOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return TransactGetItemsOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactGetItemsOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactGetItemsOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ExecuteStatementOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ExecuteStatementOutputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ExecuteStatementOutputTransformInput":
+ """Creates a ExecuteStatementOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return ExecuteStatementOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ExecuteStatementOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ExecuteStatementOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ScanInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a Scan operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ScanInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ScanInputTransformInput":
+ """Creates a ScanInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return ScanInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ScanInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ScanInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ScanInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a Scan
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ScanInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ScanInputTransformOutput":
+ """Creates a ScanInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return ScanInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ScanInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ScanInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchWriteItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a BatchWriteItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchWriteItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchWriteItemInputTransformInput":
+ """Creates a BatchWriteItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return BatchWriteItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchWriteItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchWriteItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchWriteItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a
+ BatchWriteItem operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchWriteItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchWriteItemInputTransformOutput":
+ """Creates a BatchWriteItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return BatchWriteItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchWriteItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchWriteItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchExecuteStatementOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchExecuteStatementOutputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchExecuteStatementOutputTransformInput":
+ """Creates a BatchExecuteStatementOutputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return BatchExecuteStatementOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchExecuteStatementOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchExecuteStatementOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchGetItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a BatchGetItem
+ operation.
+ :param original_input: Represents the input of a BatchGetItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchGetItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchGetItemOutputTransformInput":
+ """Creates a BatchGetItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return BatchGetItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchGetItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchGetItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DeleteItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a DeleteItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DeleteItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DeleteItemInputTransformInput":
+ """Creates a DeleteItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return DeleteItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DeleteItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DeleteItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DeleteItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a DeleteItem
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DeleteItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DeleteItemInputTransformOutput":
+ """Creates a DeleteItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return DeleteItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DeleteItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DeleteItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PutItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a PutItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the PutItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PutItemInputTransformInput":
+ """Creates a PutItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return PutItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "PutItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, PutItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PutItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a PutItem
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the PutItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PutItemInputTransformOutput":
+ """Creates a PutItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return PutItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "PutItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, PutItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class QueryInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of a Query operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the QueryInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "QueryInputTransformInput":
+ """Creates a QueryInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return QueryInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "QueryInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, QueryInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class QueryInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of a Query
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the QueryInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "QueryInputTransformOutput":
+ """Creates a QueryInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return QueryInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "QueryInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, QueryInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchWriteItemOutputTransformOutput:
+ transformed_output: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_output: "dict[str, Any]",
+ ):
+ """
+ :param transformed_output: Represents the output of a
+ BatchWriteItem operation.
+ """
+ self.transformed_output = transformed_output
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchWriteItemOutputTransformOutput to a dictionary."""
+ return {
+ "transformed_output": self.transformed_output.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchWriteItemOutputTransformOutput":
+ """Creates a BatchWriteItemOutputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_output": d["transformed_output"],
+ }
+
+ return BatchWriteItemOutputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchWriteItemOutputTransformOutput("
+ if self.transformed_output is not None:
+ result += f"transformed_output={repr(self.transformed_output)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchWriteItemOutputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_output",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ScanOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a Scan
+ operation.
+ :param original_input: Represents the input of a Scan
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ScanOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ScanOutputTransformInput":
+ """Creates a ScanOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return ScanOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ScanOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ScanOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class UpdateItemInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_input: Represents the input of an UpdateItem
+ operation.
+ """
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the UpdateItemInputTransformInput to a dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "UpdateItemInputTransformInput":
+ """Creates a UpdateItemInputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return UpdateItemInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "UpdateItemInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, UpdateItemInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class UpdateItemInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ """
+ :param transformed_input: Represents the input of an UpdateItem
+ operation.
+ """
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the UpdateItemInputTransformOutput to a dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "UpdateItemInputTransformOutput":
+ """Creates a UpdateItemInputTransformOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return UpdateItemInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "UpdateItemInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, UpdateItemInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DeleteItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a DeleteItem
+ operation.
+ :param original_input: Represents the input of a DeleteItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DeleteItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DeleteItemOutputTransformInput":
+ """Creates a DeleteItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return DeleteItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DeleteItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DeleteItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PutItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a PutItem
+ operation.
+ :param original_input: Represents the input of a PutItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the PutItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PutItemOutputTransformInput":
+ """Creates a PutItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return PutItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "PutItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, PutItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class QueryOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a Query
+ operation.
+ :param original_input: Represents the input of a Query
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the QueryOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "QueryOutputTransformInput":
+ """Creates a QueryOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return QueryOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "QueryOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, QueryOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class UpdateItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of an UpdateItem
+ operation.
+ :param original_input: Represents the input of an UpdateItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the UpdateItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "UpdateItemOutputTransformInput":
+ """Creates a UpdateItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return UpdateItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "UpdateItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, UpdateItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class BatchWriteItemOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ """
+ :param sdk_output: Represents the output of a BatchWriteItem
+ operation.
+ :param original_input: Represents the input of a BatchWriteItem
+ operation.
+ """
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the BatchWriteItemOutputTransformInput to a dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "BatchWriteItemOutputTransformInput":
+ """Creates a BatchWriteItemOutputTransformInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return BatchWriteItemOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "BatchWriteItemOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, BatchWriteItemOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactWriteItemsInputTransformInput:
+ sdk_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_input: "dict[str, Any]",
+ ):
+ self.sdk_input = sdk_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactWriteItemsInputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_input": self.sdk_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactWriteItemsInputTransformInput":
+ """Creates a TransactWriteItemsInputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_input": d["sdk_input"],
+ }
+
+ return TransactWriteItemsInputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactWriteItemsInputTransformInput("
+ if self.sdk_input is not None:
+ result += f"sdk_input={repr(self.sdk_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactWriteItemsInputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactWriteItemsInputTransformOutput:
+ transformed_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ transformed_input: "dict[str, Any]",
+ ):
+ self.transformed_input = transformed_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactWriteItemsInputTransformOutput to a
+ dictionary."""
+ return {
+ "transformed_input": self.transformed_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactWriteItemsInputTransformOutput":
+ """Creates a TransactWriteItemsInputTransformOutput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "transformed_input": d["transformed_input"],
+ }
+
+ return TransactWriteItemsInputTransformOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactWriteItemsInputTransformOutput("
+ if self.transformed_input is not None:
+ result += f"transformed_input={repr(self.transformed_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactWriteItemsInputTransformOutput):
+ return False
+ attributes: list[str] = [
+ "transformed_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class TransactWriteItemsOutputTransformInput:
+ sdk_output: "dict[str, Any]"
+ original_input: "dict[str, Any]"
+
+ def __init__(
+ self,
+ *,
+ sdk_output: "dict[str, Any]",
+ original_input: "dict[str, Any]",
+ ):
+ self.sdk_output = sdk_output
+ self.original_input = original_input
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the TransactWriteItemsOutputTransformInput to a
+ dictionary."""
+ return {
+ "sdk_output": self.sdk_output.as_dict(),
+ "original_input": self.original_input.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "TransactWriteItemsOutputTransformInput":
+ """Creates a TransactWriteItemsOutputTransformInput from a
+ dictionary."""
+ kwargs: Dict[str, Any] = {
+ "sdk_output": d["sdk_output"],
+ "original_input": d["original_input"],
+ }
+
+ return TransactWriteItemsOutputTransformInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "TransactWriteItemsOutputTransformInput("
+ if self.sdk_output is not None:
+ result += f"sdk_output={repr(self.sdk_output)}, "
+
+ if self.original_input is not None:
+ result += f"original_input={repr(self.original_input)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, TransactWriteItemsOutputTransformInput):
+ return False
+ attributes: list[str] = [
+ "sdk_output",
+ "original_input",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class Unit:
+ pass
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/plugin.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/plugin.py
new file mode 100644
index 000000000..fb35aa7dd
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/plugin.py
@@ -0,0 +1,51 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from .config import (
+ Config,
+ Plugin,
+ smithy_config_to_dafny_config,
+ DynamoDbTablesEncryptionConfig,
+)
+from smithy_python.interfaces.retries import RetryStrategy
+from smithy_python.exceptions import SmithyRetryException
+from .dafnyImplInterface import DafnyImplInterface
+
+
+def set_config_impl(config: Config):
+ """Set the Dafny-compiled implementation in the Smithy-Python client Config
+ and load our custom NoRetriesStrategy."""
+ config.dafnyImplInterface = DafnyImplInterface()
+ if isinstance(config, DynamoDbTablesEncryptionConfig):
+ from aws_dbesdk_dynamodb.internaldafny.generated.DynamoDbEncryptionTransforms import (
+ default__,
+ )
+
+ config.dafnyImplInterface.impl = default__.DynamoDbEncryptionTransforms(
+ smithy_config_to_dafny_config(config)
+ ).value
+ config.retry_strategy = NoRetriesStrategy()
+
+
+class ZeroRetryDelayToken:
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not wait to retry.
+ """
+
+ retry_delay = 0
+
+
+class NoRetriesStrategy(RetryStrategy):
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not retry calling Dafny code.
+ """
+
+ def acquire_initial_retry_token(self):
+ return ZeroRetryDelayToken()
+
+ def refresh_retry_token_for_retry(self, token_to_renew, error_info):
+ # Do not retry
+ raise SmithyRetryException()
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/serialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/serialize.py
new file mode 100644
index 000000000..b9d2cd1f1
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/serialize.py
@@ -0,0 +1,252 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny
+
+from .dafny_protocol import DafnyRequest
+
+from .config import Config
+
+
+def _serialize_put_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="PutItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_put_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="PutItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_get_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="GetItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_get_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="GetItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_write_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchWriteItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_write_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchWriteItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_get_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchGetItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_get_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchGetItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_scan_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ScanInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_scan_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ScanOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_query_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="QueryInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_query_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="QueryOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_transact_write_items_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="TransactWriteItemsInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_transact_write_items_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="TransactWriteItemsOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_update_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="UpdateItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_update_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="UpdateItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_delete_item_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="DeleteItemInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_delete_item_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="DeleteItemOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_transact_get_items_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="TransactGetItemsInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_transact_get_items_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="TransactGetItemsOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_execute_statement_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ExecuteStatementInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_execute_statement_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ExecuteStatementOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_execute_statement_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchExecuteStatementInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_batch_execute_statement_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="BatchExecuteStatementOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_execute_transaction_input_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ExecuteTransactionInputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_execute_transaction_output_transform(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ExecuteTransactionOutputTransform",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformInput(
+ input
+ ),
+ )
+
+
+def _serialize_resolve_attributes(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ResolveAttributes",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesInput(
+ input
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/smithy_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/smithy_to_dafny.py
new file mode 100644
index 000000000..74a1601e9
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_transforms/smithy_to_dafny.py
@@ -0,0 +1,703 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+import aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTransformsTypes import (
+ BatchExecuteStatementInputTransformInput_BatchExecuteStatementInputTransformInput as DafnyBatchExecuteStatementInputTransformInput,
+ BatchExecuteStatementInputTransformOutput_BatchExecuteStatementInputTransformOutput as DafnyBatchExecuteStatementInputTransformOutput,
+ BatchExecuteStatementOutputTransformInput_BatchExecuteStatementOutputTransformInput as DafnyBatchExecuteStatementOutputTransformInput,
+ BatchExecuteStatementOutputTransformOutput_BatchExecuteStatementOutputTransformOutput as DafnyBatchExecuteStatementOutputTransformOutput,
+ BatchGetItemInputTransformInput_BatchGetItemInputTransformInput as DafnyBatchGetItemInputTransformInput,
+ BatchGetItemInputTransformOutput_BatchGetItemInputTransformOutput as DafnyBatchGetItemInputTransformOutput,
+ BatchGetItemOutputTransformInput_BatchGetItemOutputTransformInput as DafnyBatchGetItemOutputTransformInput,
+ BatchGetItemOutputTransformOutput_BatchGetItemOutputTransformOutput as DafnyBatchGetItemOutputTransformOutput,
+ BatchWriteItemInputTransformInput_BatchWriteItemInputTransformInput as DafnyBatchWriteItemInputTransformInput,
+ BatchWriteItemInputTransformOutput_BatchWriteItemInputTransformOutput as DafnyBatchWriteItemInputTransformOutput,
+ BatchWriteItemOutputTransformInput_BatchWriteItemOutputTransformInput as DafnyBatchWriteItemOutputTransformInput,
+ BatchWriteItemOutputTransformOutput_BatchWriteItemOutputTransformOutput as DafnyBatchWriteItemOutputTransformOutput,
+ DeleteItemInputTransformInput_DeleteItemInputTransformInput as DafnyDeleteItemInputTransformInput,
+ DeleteItemInputTransformOutput_DeleteItemInputTransformOutput as DafnyDeleteItemInputTransformOutput,
+ DeleteItemOutputTransformInput_DeleteItemOutputTransformInput as DafnyDeleteItemOutputTransformInput,
+ DeleteItemOutputTransformOutput_DeleteItemOutputTransformOutput as DafnyDeleteItemOutputTransformOutput,
+ ExecuteStatementInputTransformInput_ExecuteStatementInputTransformInput as DafnyExecuteStatementInputTransformInput,
+ ExecuteStatementInputTransformOutput_ExecuteStatementInputTransformOutput as DafnyExecuteStatementInputTransformOutput,
+ ExecuteStatementOutputTransformInput_ExecuteStatementOutputTransformInput as DafnyExecuteStatementOutputTransformInput,
+ ExecuteStatementOutputTransformOutput_ExecuteStatementOutputTransformOutput as DafnyExecuteStatementOutputTransformOutput,
+ ExecuteTransactionInputTransformInput_ExecuteTransactionInputTransformInput as DafnyExecuteTransactionInputTransformInput,
+ ExecuteTransactionInputTransformOutput_ExecuteTransactionInputTransformOutput as DafnyExecuteTransactionInputTransformOutput,
+ ExecuteTransactionOutputTransformInput_ExecuteTransactionOutputTransformInput as DafnyExecuteTransactionOutputTransformInput,
+ ExecuteTransactionOutputTransformOutput_ExecuteTransactionOutputTransformOutput as DafnyExecuteTransactionOutputTransformOutput,
+ GetItemInputTransformInput_GetItemInputTransformInput as DafnyGetItemInputTransformInput,
+ GetItemInputTransformOutput_GetItemInputTransformOutput as DafnyGetItemInputTransformOutput,
+ GetItemOutputTransformInput_GetItemOutputTransformInput as DafnyGetItemOutputTransformInput,
+ GetItemOutputTransformOutput_GetItemOutputTransformOutput as DafnyGetItemOutputTransformOutput,
+ PutItemInputTransformInput_PutItemInputTransformInput as DafnyPutItemInputTransformInput,
+ PutItemInputTransformOutput_PutItemInputTransformOutput as DafnyPutItemInputTransformOutput,
+ PutItemOutputTransformInput_PutItemOutputTransformInput as DafnyPutItemOutputTransformInput,
+ PutItemOutputTransformOutput_PutItemOutputTransformOutput as DafnyPutItemOutputTransformOutput,
+ QueryInputTransformInput_QueryInputTransformInput as DafnyQueryInputTransformInput,
+ QueryInputTransformOutput_QueryInputTransformOutput as DafnyQueryInputTransformOutput,
+ QueryOutputTransformInput_QueryOutputTransformInput as DafnyQueryOutputTransformInput,
+ QueryOutputTransformOutput_QueryOutputTransformOutput as DafnyQueryOutputTransformOutput,
+ ResolveAttributesInput_ResolveAttributesInput as DafnyResolveAttributesInput,
+ ResolveAttributesOutput_ResolveAttributesOutput as DafnyResolveAttributesOutput,
+ ScanInputTransformInput_ScanInputTransformInput as DafnyScanInputTransformInput,
+ ScanInputTransformOutput_ScanInputTransformOutput as DafnyScanInputTransformOutput,
+ ScanOutputTransformInput_ScanOutputTransformInput as DafnyScanOutputTransformInput,
+ ScanOutputTransformOutput_ScanOutputTransformOutput as DafnyScanOutputTransformOutput,
+ TransactGetItemsInputTransformInput_TransactGetItemsInputTransformInput as DafnyTransactGetItemsInputTransformInput,
+ TransactGetItemsInputTransformOutput_TransactGetItemsInputTransformOutput as DafnyTransactGetItemsInputTransformOutput,
+ TransactGetItemsOutputTransformInput_TransactGetItemsOutputTransformInput as DafnyTransactGetItemsOutputTransformInput,
+ TransactGetItemsOutputTransformOutput_TransactGetItemsOutputTransformOutput as DafnyTransactGetItemsOutputTransformOutput,
+ TransactWriteItemsInputTransformInput_TransactWriteItemsInputTransformInput as DafnyTransactWriteItemsInputTransformInput,
+ TransactWriteItemsInputTransformOutput_TransactWriteItemsInputTransformOutput as DafnyTransactWriteItemsInputTransformOutput,
+ TransactWriteItemsOutputTransformInput_TransactWriteItemsOutputTransformInput as DafnyTransactWriteItemsOutputTransformInput,
+ TransactWriteItemsOutputTransformOutput_TransactWriteItemsOutputTransformOutput as DafnyTransactWriteItemsOutputTransformOutput,
+ UpdateItemInputTransformInput_UpdateItemInputTransformInput as DafnyUpdateItemInputTransformInput,
+ UpdateItemInputTransformOutput_UpdateItemInputTransformOutput as DafnyUpdateItemInputTransformOutput,
+ UpdateItemOutputTransformInput_UpdateItemOutputTransformInput as DafnyUpdateItemOutputTransformInput,
+ UpdateItemOutputTransformOutput_UpdateItemOutputTransformOutput as DafnyUpdateItemOutputTransformOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+from smithy_dafny_standard_library.internaldafny.generated.Wrappers import (
+ Option_None,
+ Option_Some,
+)
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformInput(
+ native_input,
+):
+ return DafnyPutItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformInput(
+ native_input,
+):
+ return DafnyPutItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformInput(
+ native_input,
+):
+ return DafnyGetItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_GetItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformInput(
+ native_input,
+):
+ return DafnyGetItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_GetItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_GetItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformInput(
+ native_input,
+):
+ return DafnyBatchWriteItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchWriteItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformInput(
+ native_input,
+):
+ return DafnyBatchWriteItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchWriteItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchWriteItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformInput(
+ native_input,
+):
+ return DafnyBatchGetItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchGetItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformInput(
+ native_input,
+):
+ return DafnyBatchGetItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchGetItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchGetItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformInput(
+ native_input,
+):
+ return DafnyScanInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ScanInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformInput(
+ native_input,
+):
+ return DafnyScanOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ScanOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ScanInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformInput(
+ native_input,
+):
+ return DafnyQueryInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_QueryInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformInput(
+ native_input,
+):
+ return DafnyQueryOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_QueryOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_QueryInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformInput(
+ native_input,
+):
+ return DafnyTransactWriteItemsInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformInput(
+ native_input,
+):
+ return DafnyTransactWriteItemsOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItemsOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformInput(
+ native_input,
+):
+ return DafnyUpdateItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_UpdateItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformInput(
+ native_input,
+):
+ return DafnyUpdateItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_UpdateItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_UpdateItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformInput(
+ native_input,
+):
+ return DafnyDeleteItemInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteItemInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformInput(
+ native_input,
+):
+ return DafnyDeleteItemOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteItemOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteItemInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformInput(
+ native_input,
+):
+ return DafnyTransactGetItemsInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItemsInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformInput(
+ native_input,
+):
+ return DafnyTransactGetItemsOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItemsOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItemsInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformInput(
+ native_input,
+):
+ return DafnyExecuteStatementInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteStatementInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformInput(
+ native_input,
+):
+ return DafnyExecuteStatementOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteStatementOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteStatementInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformInput(
+ native_input,
+):
+ return DafnyBatchExecuteStatementInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformInput(
+ native_input,
+):
+ return DafnyBatchExecuteStatementOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchExecuteStatementOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformInput(
+ native_input,
+):
+ return DafnyExecuteTransactionInputTransformInput(
+ sdkInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ native_input.sdk_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformInput(
+ native_input,
+):
+ return DafnyExecuteTransactionOutputTransformInput(
+ sdkOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteTransactionOutput(
+ native_input.sdk_output
+ ),
+ originalInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ native_input.original_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesInput(
+ native_input,
+):
+ return DafnyResolveAttributesInput(
+ TableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ Item=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
+ value
+ )
+ for (key, value) in native_input.item.items()
+ }
+ ),
+ Version=((Option_Some(native_input.version)) if (native_input.version is not None) else (Option_None())),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemInputTransformOutput(
+ native_input,
+):
+ return DafnyPutItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_PutItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyPutItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_PutItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemInputTransformOutput(
+ native_input,
+):
+ return DafnyGetItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_GetItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_GetItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyGetItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_GetItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemInputTransformOutput(
+ native_input,
+):
+ return DafnyBatchWriteItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchWriteItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchWriteItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyBatchWriteItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchWriteItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemInputTransformOutput(
+ native_input,
+):
+ return DafnyBatchGetItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchGetItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchGetItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyBatchGetItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchGetItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanInputTransformOutput(
+ native_input,
+):
+ return DafnyScanInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ScanInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ScanOutputTransformOutput(
+ native_input,
+):
+ return DafnyScanOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ScanOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryInputTransformOutput(
+ native_input,
+):
+ return DafnyQueryInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_QueryInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_QueryOutputTransformOutput(
+ native_input,
+):
+ return DafnyQueryOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_QueryOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsInputTransformOutput(
+ native_input,
+):
+ return DafnyTransactWriteItemsInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItemsInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactWriteItemsOutputTransformOutput(
+ native_input,
+):
+ return DafnyTransactWriteItemsOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactWriteItemsOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemInputTransformOutput(
+ native_input,
+):
+ return DafnyUpdateItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_UpdateItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_UpdateItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyUpdateItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_UpdateItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemInputTransformOutput(
+ native_input,
+):
+ return DafnyDeleteItemInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteItemInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DeleteItemOutputTransformOutput(
+ native_input,
+):
+ return DafnyDeleteItemOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_DeleteItemOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsInputTransformOutput(
+ native_input,
+):
+ return DafnyTransactGetItemsInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItemsInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_TransactGetItemsOutputTransformOutput(
+ native_input,
+):
+ return DafnyTransactGetItemsOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_TransactGetItemsOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementInputTransformOutput(
+ native_input,
+):
+ return DafnyExecuteStatementInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteStatementInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteStatementOutputTransformOutput(
+ native_input,
+):
+ return DafnyExecuteStatementOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteStatementOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementInputTransformOutput(
+ native_input,
+):
+ return DafnyBatchExecuteStatementInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchExecuteStatementInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_BatchExecuteStatementOutputTransformOutput(
+ native_input,
+):
+ return DafnyBatchExecuteStatementOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_BatchExecuteStatementOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionInputTransformOutput(
+ native_input,
+):
+ return DafnyExecuteTransactionInputTransformOutput(
+ transformedInput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteTransactionInput(
+ native_input.transformed_input
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ExecuteTransactionOutputTransformOutput(
+ native_input,
+):
+ return DafnyExecuteTransactionOutputTransformOutput(
+ transformedOutput=aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_ExecuteTransactionOutput(
+ native_input.transformed_output
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_ResolveAttributesOutput(
+ native_input,
+):
+ return DafnyResolveAttributesOutput(
+ VirtualFields=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)])
+ )
+ for (key, value) in native_input.virtual_fields.items()
+ }
+ ),
+ CompoundBeacons=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(value.encode("utf-16-be"))] * 2)])
+ )
+ for (key, value) in native_input.compound_beacons.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_AwsCryptographicMaterialProvidersReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DynamoDbEncryptionReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_DynamoDbItemEncryptorReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_dynamodb_transforms_StructuredEncryptionReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/__init__.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/client.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/client.py
new file mode 100644
index 000000000..8164df31e
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/client.py
@@ -0,0 +1,395 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ IStructuredEncryptionClient,
+)
+from typing import Callable, TypeVar, cast
+
+from .config import Config, StructuredEncryptionConfig
+from .dafny_protocol import DafnyRequest, DafnyResponse
+from .plugin import set_config_impl
+from smithy_python.exceptions import SmithyRetryException
+from smithy_python.interfaces.interceptor import Interceptor, InterceptorContext
+from smithy_python.interfaces.retries import RetryErrorInfo, RetryErrorType
+
+from .config import Plugin
+from .deserialize import (
+ _deserialize_decrypt_path_structure,
+ _deserialize_decrypt_structure,
+ _deserialize_encrypt_path_structure,
+ _deserialize_encrypt_structure,
+ _deserialize_resolve_auth_actions,
+)
+from .errors import ServiceError
+from .models import (
+ DecryptPathStructureInput,
+ DecryptPathStructureOutput,
+ DecryptStructureInput,
+ DecryptStructureOutput,
+ EncryptPathStructureInput,
+ EncryptPathStructureOutput,
+ EncryptStructureInput,
+ EncryptStructureOutput,
+ ResolveAuthActionsInput,
+ ResolveAuthActionsOutput,
+)
+from .serialize import (
+ _serialize_decrypt_path_structure,
+ _serialize_decrypt_structure,
+ _serialize_encrypt_path_structure,
+ _serialize_encrypt_structure,
+ _serialize_resolve_auth_actions,
+)
+
+
+Input = TypeVar("Input")
+Output = TypeVar("Output")
+
+
+class StructuredEncryption:
+ """Client for StructuredEncryption.
+
+ :param config: Configuration for the client.
+ """
+
+ def __init__(
+ self,
+ config: StructuredEncryptionConfig | None = None,
+ dafny_client: IStructuredEncryptionClient | None = None,
+ ):
+ if config is None:
+ self._config = Config()
+ else:
+ self._config = config
+
+ client_plugins: list[Plugin] = [
+ set_config_impl,
+ ]
+
+ for plugin in client_plugins:
+ plugin(self._config)
+
+ if dafny_client is not None:
+ self._config.dafnyImplInterface.impl = dafny_client
+
+ def encrypt_structure(self, input: EncryptStructureInput) -> EncryptStructureOutput:
+ """Invokes the EncryptStructure operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_encrypt_structure,
+ deserialize=_deserialize_encrypt_structure,
+ config=self._config,
+ operation_name="EncryptStructure",
+ )
+
+ def decrypt_structure(self, input: DecryptStructureInput) -> DecryptStructureOutput:
+ """Invokes the DecryptStructure operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_decrypt_structure,
+ deserialize=_deserialize_decrypt_structure,
+ config=self._config,
+ operation_name="DecryptStructure",
+ )
+
+ def encrypt_path_structure(self, input: EncryptPathStructureInput) -> EncryptPathStructureOutput:
+ """Invokes the EncryptPathStructure operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_encrypt_path_structure,
+ deserialize=_deserialize_encrypt_path_structure,
+ config=self._config,
+ operation_name="EncryptPathStructure",
+ )
+
+ def decrypt_path_structure(self, input: DecryptPathStructureInput) -> DecryptPathStructureOutput:
+ """Invokes the DecryptPathStructure operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_decrypt_path_structure,
+ deserialize=_deserialize_decrypt_path_structure,
+ config=self._config,
+ operation_name="DecryptPathStructure",
+ )
+
+ def resolve_auth_actions(self, input: ResolveAuthActionsInput) -> ResolveAuthActionsOutput:
+ """Invokes the ResolveAuthActions operation.
+
+ :param input: The operation's input.
+ """
+ return self._execute_operation(
+ input=input,
+ plugins=[],
+ serialize=_serialize_resolve_auth_actions,
+ deserialize=_deserialize_resolve_auth_actions,
+ config=self._config,
+ operation_name="ResolveAuthActions",
+ )
+
+ def _execute_operation(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ try:
+ return self._handle_execution(input, plugins, serialize, deserialize, config, operation_name)
+ except Exception as e:
+ # Make sure every exception that we throw is an instance of ServiceError so
+ # customers can reliably catch everything we throw.
+ if not isinstance(e, ServiceError):
+ raise ServiceError(e) from e
+ raise e
+
+ def _handle_execution(
+ self,
+ input: Input,
+ plugins: list[Plugin],
+ serialize: Callable[[Input, Config], DafnyRequest],
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ config: Config,
+ operation_name: str,
+ ) -> Output:
+ context: InterceptorContext[Input, None, None, None] = InterceptorContext(
+ request=input,
+ response=None,
+ transport_request=None,
+ transport_response=None,
+ )
+ try:
+ _client_interceptors = config.interceptors
+ except AttributeError:
+ config.interceptors = []
+ _client_interceptors = config.interceptors
+ client_interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+ interceptors = client_interceptors
+
+ try:
+ # Step 1a: Invoke read_before_execution on client-level interceptors
+ for interceptor in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 1b: Run operation-level plugins
+ for plugin in plugins:
+ plugin(config)
+
+ _client_interceptors = config.interceptors
+ interceptors = cast(
+ list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ _client_interceptors,
+ )
+
+ # Step 1c: Invoke the read_before_execution hooks on newly added
+ # interceptors.
+ for interceptor in interceptors:
+ if interceptor not in client_interceptors:
+ interceptor.read_before_execution(context)
+
+ # Step 2: Invoke the modify_before_serialization hooks
+ for interceptor in interceptors:
+ context._request = interceptor.modify_before_serialization(context)
+
+ # Step 3: Invoke the read_before_serialization hooks
+ for interceptor in interceptors:
+ interceptor.read_before_serialization(context)
+
+ # Step 4: Serialize the request
+ context_with_transport_request = cast(InterceptorContext[Input, None, DafnyRequest, None], context)
+ context_with_transport_request._transport_request = serialize(
+ context_with_transport_request.request, config
+ )
+
+ # Step 5: Invoke read_after_serialization
+ for interceptor in interceptors:
+ interceptor.read_after_serialization(context_with_transport_request)
+
+ # Step 6: Invoke modify_before_retry_loop
+ for interceptor in interceptors:
+ context_with_transport_request._transport_request = interceptor.modify_before_retry_loop(
+ context_with_transport_request
+ )
+
+ # Step 7: Acquire the retry token.
+ retry_strategy = config.retry_strategy
+ retry_token = retry_strategy.acquire_initial_retry_token()
+
+ while True:
+ # Make an attempt, creating a copy of the context so we don't pass
+ # around old data.
+ context_with_response = self._handle_attempt(
+ deserialize,
+ interceptors,
+ context_with_transport_request.copy(),
+ config,
+ operation_name,
+ )
+
+ # We perform this type-ignored re-assignment because `context` needs
+ # to point at the latest context so it can be generically handled
+ # later on. This is only an issue here because we've created a copy,
+ # so we're no longer simply pointing at the same object in memory
+ # with different names and type hints. It is possible to address this
+ # without having to fall back to the type ignore, but it would impose
+ # unnecessary runtime costs.
+ context = context_with_response # type: ignore
+
+ if isinstance(context_with_response.response, Exception):
+ # Step 7u: Reacquire retry token if the attempt failed
+ try:
+ retry_token = retry_strategy.refresh_retry_token_for_retry(
+ token_to_renew=retry_token,
+ error_info=RetryErrorInfo(
+ # TODO: Determine the error type.
+ error_type=RetryErrorType.CLIENT_ERROR,
+ ),
+ )
+ except SmithyRetryException:
+ raise context_with_response.response
+ else:
+ # Step 8: Invoke record_success
+ retry_strategy.record_success(token=retry_token)
+ break
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request will have been definitively set, and
+ # The response will be set either with the modeled output or an exception. The
+ # transport_request and transport_response may be set or None.
+ execution_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_execution(interceptors, execution_context)
+
+ def _handle_attempt(
+ self,
+ deserialize: Callable[[DafnyResponse, Config], Output],
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, None, DafnyRequest, None],
+ config: Config,
+ operation_name: str,
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ try:
+ # Step 7a: Invoke read_before_attempt
+ for interceptor in interceptors:
+ interceptor.read_before_attempt(context)
+
+ # Step 7m: Involve client Dafny impl
+ if config.dafnyImplInterface.impl is None:
+ raise Exception("No impl found on the operation config.")
+
+ context_with_response = cast(InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context)
+
+ context_with_response._transport_response = config.dafnyImplInterface.handle_request(
+ input=context_with_response.transport_request
+ )
+
+ # Step 7n: Invoke read_after_transmit
+ for interceptor in interceptors:
+ interceptor.read_after_transmit(context_with_response)
+
+ # Step 7o: Invoke modify_before_deserialization
+ for interceptor in interceptors:
+ context_with_response._transport_response = interceptor.modify_before_deserialization(
+ context_with_response
+ )
+
+ # Step 7p: Invoke read_before_deserialization
+ for interceptor in interceptors:
+ interceptor.read_before_deserialization(context_with_response)
+
+ # Step 7q: deserialize
+ context_with_output = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse],
+ context_with_response,
+ )
+ context_with_output._response = deserialize(context_with_output._transport_response, config)
+
+ # Step 7r: Invoke read_after_deserialization
+ for interceptor in interceptors:
+ interceptor.read_after_deserialization(context_with_output)
+ except Exception as e:
+ context._response = e
+
+ # At this point, the context's request and transport_request have definitively been set,
+ # the response is either set or an exception, and the transport_resposne is either set or
+ # None. This will also be true after _finalize_attempt because there is no opportunity
+ # there to set the transport_response.
+ attempt_context = cast(
+ InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ context,
+ )
+ return self._finalize_attempt(interceptors, attempt_context)
+
+ def _finalize_attempt(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None],
+ ) -> InterceptorContext[Input, Output, DafnyRequest, DafnyResponse | None]:
+ # Step 7s: Invoke modify_before_attempt_completion
+ try:
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_attempt_completion(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 7t: Invoke read_after_attempt
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_attempt(context)
+ except Exception as e:
+ context._response = e
+
+ return context
+
+ def _finalize_execution(
+ self,
+ interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
+ context: InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
+ ) -> Output:
+ try:
+ # Step 9: Invoke modify_before_completion
+ for interceptor in interceptors:
+ context._response = interceptor.modify_before_completion(context)
+
+ except Exception as e:
+ context._response = e
+
+ # Step 11: Invoke read_after_execution
+ for interceptor in interceptors:
+ try:
+ interceptor.read_after_execution(context)
+ except Exception as e:
+ context._response = e
+
+ # Step 12: Return / throw
+ if isinstance(context.response, Exception):
+ raise context.response
+
+ # We may want to add some aspects of this context to the output types so we can
+ # return it to the end-users.
+ return context.response
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/config.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/config.py
new file mode 100644
index 000000000..7e3a3db13
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/config.py
@@ -0,0 +1,92 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ StructuredEncryptionConfig_StructuredEncryptionConfig as DafnyStructuredEncryptionConfig,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, TypeAlias
+
+from .dafnyImplInterface import DafnyImplInterface
+from smithy_python._private.retries import SimpleRetryStrategy
+from smithy_python.interfaces.retries import RetryStrategy
+
+
+_ServiceInterceptor = Any
+
+
+@dataclass(init=False)
+class Config:
+ """Configuration for StructuredEncryption."""
+
+ interceptors: list[_ServiceInterceptor]
+ retry_strategy: RetryStrategy
+ dafnyImplInterface: DafnyImplInterface | None
+
+ def __init__(
+ self,
+ *,
+ interceptors: list[_ServiceInterceptor] | None = None,
+ retry_strategy: RetryStrategy | None = None,
+ dafnyImplInterface: DafnyImplInterface | None = None,
+ ):
+ """Constructor.
+
+ :param interceptors: The list of interceptors, which are hooks
+ that are called during the execution of a request.
+ :param retry_strategy: The retry strategy for issuing retry
+ tokens and computing retry delays.
+ :param dafnyImplInterface:
+ """
+ self.interceptors = interceptors or []
+ self.retry_strategy = retry_strategy or SimpleRetryStrategy()
+ self.dafnyImplInterface = dafnyImplInterface
+
+
+# A callable that allows customizing the config object on each request.
+Plugin: TypeAlias = Callable[[Config], None]
+
+
+class StructuredEncryptionConfig(Config):
+ def __init__(
+ self,
+ ):
+ """Constructor for StructuredEncryptionConfig."""
+ super().__init__()
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the StructuredEncryptionConfig to a dictionary."""
+ return {}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "StructuredEncryptionConfig":
+ """Creates a StructuredEncryptionConfig from a dictionary."""
+ return StructuredEncryptionConfig()
+
+ def __repr__(self) -> str:
+ result = "StructuredEncryptionConfig("
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ return isinstance(other, StructuredEncryptionConfig)
+
+
+def dafny_config_to_smithy_config(dafny_config) -> StructuredEncryptionConfig:
+ """Converts the provided Dafny shape for this localService's config into
+ the corresponding Smithy-modelled shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredEncryptionConfig(
+ dafny_config
+ )
+
+
+def smithy_config_to_dafny_config(smithy_config) -> DafnyStructuredEncryptionConfig:
+ """Converts the provided Smithy-modelled shape for this localService's
+ config into the corresponding Dafny shape."""
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredEncryptionConfig(
+ smithy_config
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafnyImplInterface.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafnyImplInterface.py
new file mode 100644
index 000000000..95cbd13d5
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafnyImplInterface.py
@@ -0,0 +1,37 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.StructuredEncryption import (
+ StructuredEncryptionClient,
+)
+from .dafny_protocol import DafnyRequest
+
+
+class DafnyImplInterface:
+ impl: StructuredEncryptionClient | None = None
+
+ # operation_map cannot be created at dafnyImplInterface create time,
+ # as the map's values reference values inside `self.impl`,
+ # and impl is only populated at runtime.
+ # Accessing these before impl is populated results in an error.
+ # At runtime, the map is populated once and cached.
+ operation_map = None
+
+ def handle_request(self, input: DafnyRequest):
+ if self.operation_map is None:
+ self.operation_map = {
+ "EncryptStructure": self.impl.EncryptStructure,
+ "DecryptStructure": self.impl.DecryptStructure,
+ "EncryptPathStructure": self.impl.EncryptPathStructure,
+ "DecryptPathStructure": self.impl.DecryptPathStructure,
+ "ResolveAuthActions": self.impl.ResolveAuthActions,
+ }
+
+ # This logic is where a typical Smithy client would expect the "server" to be.
+ # This code can be thought of as logic our Dafny "server" uses
+ # to route incoming client requests to the correct request handler code.
+ if input.dafny_operation_input is None:
+ return self.operation_map[input.operation_name]()
+ else:
+ return self.operation_map[input.operation_name](input.dafny_operation_input)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_protocol.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_protocol.py
new file mode 100644
index 000000000..be268714d
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_protocol.py
@@ -0,0 +1,39 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ DecryptPathStructureInput_DecryptPathStructureInput as DafnyDecryptPathStructureInput,
+ DecryptStructureInput_DecryptStructureInput as DafnyDecryptStructureInput,
+ EncryptPathStructureInput_EncryptPathStructureInput as DafnyEncryptPathStructureInput,
+ EncryptStructureInput_EncryptStructureInput as DafnyEncryptStructureInput,
+ ResolveAuthActionsInput_ResolveAuthActionsInput as DafnyResolveAuthActionsInput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+from typing import Union
+
+
+class DafnyRequest:
+ operation_name: str
+
+ # dafny_operation_input can take on any one of the types
+ # of the input values passed to the Dafny implementation
+ dafny_operation_input: Union[
+ DafnyDecryptStructureInput,
+ DafnyDecryptPathStructureInput,
+ DafnyEncryptPathStructureInput,
+ DafnyEncryptStructureInput,
+ DafnyResolveAuthActionsInput,
+ ]
+
+ def __init__(self, operation_name, dafny_operation_input):
+ self.operation_name = operation_name
+ self.dafny_operation_input = dafny_operation_input
+
+
+class DafnyResponse(Wrappers.Result):
+ def __init__(self):
+ super().__init__(self)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_to_smithy.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_to_smithy.py
new file mode 100644
index 000000000..32e97a286
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/dafny_to_smithy.py
@@ -0,0 +1,435 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ AuthenticateAction_DO__NOT__SIGN,
+ AuthenticateAction_SIGN,
+ CryptoAction_DO__NOTHING,
+ CryptoAction_ENCRYPT__AND__SIGN,
+ CryptoAction_SIGN__AND__INCLUDE__IN__ENCRYPTION__CONTEXT,
+ CryptoAction_SIGN__ONLY,
+ PathSegment_member,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.StructuredDataTerminal(
+ value=bytes(dafny_input.value),
+ type_id=bytes(dafny_input.typeId),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(dafny_input):
+ if isinstance(dafny_input, CryptoAction_ENCRYPT__AND__SIGN):
+ return "ENCRYPT_AND_SIGN"
+
+ elif isinstance(dafny_input, CryptoAction_SIGN__AND__INCLUDE__IN__ENCRYPTION__CONTEXT):
+ return "SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT"
+
+ elif isinstance(dafny_input, CryptoAction_SIGN__ONLY):
+ return "SIGN_ONLY"
+
+ elif isinstance(dafny_input, CryptoAction_DO__NOTHING):
+ return "DO_NOTHING"
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {dafny_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.EncryptStructureInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.tableName).decode("utf-16-be"),
+ plaintext_structure={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in dafny_input.plaintextStructure.items
+ },
+ crypto_schema={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.cryptoSchema.items
+ },
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm
+ )
+ )
+ if (dafny_input.cmm is not None)
+ else None
+ ),
+ algorithm_suite_id=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId.value
+ )
+ )
+ if (dafny_input.algorithmSuiteId.is_Some)
+ else None
+ ),
+ encryption_context=(
+ (
+ {
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.value.items
+ }
+ )
+ if (dafny_input.encryptionContext.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ dafny_input,
+):
+ if isinstance(dafny_input, AuthenticateAction_SIGN):
+ return "SIGN"
+
+ elif isinstance(dafny_input, AuthenticateAction_DO__NOT__SIGN):
+ return "DO_NOT_SIGN"
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {dafny_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.DecryptStructureInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.tableName).decode("utf-16-be"),
+ encrypted_structure={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in dafny_input.encryptedStructure.items
+ },
+ authenticate_schema={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ value
+ )
+ for (key, value) in dafny_input.authenticateSchema.items
+ },
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm
+ )
+ )
+ if (dafny_input.cmm is not None)
+ else None
+ ),
+ encryption_context=(
+ (
+ {
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.value.items
+ }
+ )
+ if (dafny_input.encryptionContext.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.CryptoItem(
+ key=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(
+ list_element
+ )
+ for list_element in dafny_input.key
+ ],
+ data=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ dafny_input.data
+ ),
+ action=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ dafny_input.action
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(dafny_input):
+ # Convert PathSegment
+ if isinstance(dafny_input, PathSegment_member):
+ PathSegment_union_value = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.PathSegmentMember(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructureSegment(
+ dafny_input.member
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(dafny_input))
+
+ return PathSegment_union_value
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructureSegment(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.StructureSegment(
+ key=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.key).decode("utf-16-be"),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.EncryptPathStructureInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.tableName).decode("utf-16-be"),
+ plaintext_structure=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in dafny_input.plaintextStructure
+ ],
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm
+ )
+ )
+ if (dafny_input.cmm is not None)
+ else None
+ ),
+ algorithm_suite_id=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId.value
+ )
+ )
+ if (dafny_input.algorithmSuiteId.is_Some)
+ else None
+ ),
+ encryption_context=(
+ (
+ {
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.value.items
+ }
+ )
+ if (dafny_input.encryptionContext.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.AuthItem(
+ key=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(
+ list_element
+ )
+ for list_element in dafny_input.key
+ ],
+ data=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ dafny_input.data
+ ),
+ action=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ dafny_input.action
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.DecryptPathStructureInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.tableName).decode("utf-16-be"),
+ encrypted_structure=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(
+ list_element
+ )
+ for list_element in dafny_input.encryptedStructure
+ ],
+ cmm=(
+ (
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ dafny_input.cmm
+ )
+ )
+ if (dafny_input.cmm is not None)
+ else None
+ ),
+ encryption_context=(
+ (
+ {
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.value.items
+ }
+ )
+ if (dafny_input.encryptionContext.is_Some)
+ else None
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsInput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.ResolveAuthActionsInput(
+ table_name=b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.tableName).decode("utf-16-be"),
+ auth_actions=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(
+ list_element
+ )
+ for list_element in dafny_input.authActions
+ ],
+ header_bytes=bytes(dafny_input.headerBytes),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(dafny_input):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.ParsedHeader(
+ algorithm_suite_id=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ dafny_input.algorithmSuiteId
+ ),
+ encrypted_data_keys=[
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.dafny_to_smithy.aws_cryptography_materialproviders_EncryptedDataKey(
+ list_element
+ )
+ for list_element in dafny_input.encryptedDataKeys
+ ],
+ stored_encryption_context={
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.storedEncryptionContext.items
+ },
+ encryption_context={
+ bytes(key.Elements).decode("utf-8"): bytes(value.Elements).decode("utf-8")
+ for (key, value) in dafny_input.encryptionContext.items
+ },
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.EncryptStructureOutput(
+ encrypted_structure={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in dafny_input.encryptedStructure.items
+ },
+ crypto_schema={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.cryptoSchema.items
+ },
+ parsed_header=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ dafny_input.parsedHeader
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.DecryptStructureOutput(
+ plaintext_structure={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in dafny_input.plaintextStructure.items
+ },
+ crypto_schema={
+ b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
+ "utf-16-be"
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in dafny_input.cryptoSchema.items
+ },
+ parsed_header=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ dafny_input.parsedHeader
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.EncryptPathStructureOutput(
+ encrypted_structure=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in dafny_input.encryptedStructure
+ ],
+ parsed_header=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ dafny_input.parsedHeader
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.DecryptPathStructureOutput(
+ plaintext_structure=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in dafny_input.plaintextStructure
+ ],
+ parsed_header=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ dafny_input.parsedHeader
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsOutput(
+ dafny_input,
+):
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.ResolveAuthActionsOutput(
+ crypto_actions=[
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in dafny_input.cryptoActions
+ ],
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AtomicPrimitivesReference(
+ dafny_input,
+):
+ from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.client import (
+ AwsCryptographicPrimitives,
+ )
+
+ return AwsCryptographicPrimitives(config=None, dafny_client=dafny_input)
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructuredEncryptionConfig(
+ dafny_input,
+):
+ # Deferred import of .config to avoid circular dependency
+ import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.config
+
+ return (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.config.StructuredEncryptionConfig()
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/deserialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/deserialize.py
new file mode 100644
index 000000000..b29eb6b13
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/deserialize.py
@@ -0,0 +1,104 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ DecryptPathStructureOutput_DecryptPathStructureOutput as DafnyDecryptPathStructureOutput,
+ DecryptStructureOutput_DecryptStructureOutput as DafnyDecryptStructureOutput,
+ EncryptPathStructureOutput_EncryptPathStructureOutput as DafnyEncryptPathStructureOutput,
+ EncryptStructureOutput_EncryptStructureOutput as DafnyEncryptStructureOutput,
+ Error,
+ Error_StructuredEncryptionException,
+ ResolveAuthActionsOutput_ResolveAuthActionsOutput as DafnyResolveAuthActionsOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy
+from typing import Any
+
+from .dafny_protocol import DafnyResponse
+from .errors import (
+ AwsCryptographicMaterialProviders,
+ AwsCryptographicPrimitives,
+ CollectionOfErrors,
+ OpaqueError,
+ ServiceError,
+ StructuredEncryptionException,
+)
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.deserialize import (
+ _deserialize_error as aws_cryptography_materialproviders_deserialize_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.deserialize import (
+ _deserialize_error as aws_cryptography_primitives_deserialize_error,
+)
+
+from .config import Config
+
+
+def _deserialize_encrypt_structure(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureOutput(
+ input.value
+ )
+
+
+def _deserialize_decrypt_structure(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureOutput(
+ input.value
+ )
+
+
+def _deserialize_encrypt_path_structure(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureOutput(
+ input.value
+ )
+
+
+def _deserialize_decrypt_path_structure(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureOutput(
+ input.value
+ )
+
+
+def _deserialize_resolve_auth_actions(input: DafnyResponse, config: Config):
+
+ if input.IsFailure():
+ return _deserialize_error(input.error)
+ return aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.dafny_to_smithy.aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsOutput(
+ input.value
+ )
+
+
+def _deserialize_error(error: Error) -> ServiceError:
+ if error.is_Opaque:
+ return OpaqueError(obj=error.obj)
+ elif error.is_OpaqueWithText:
+ return OpaqueErrorWithText(obj=error.obj, obj_message=error.objMessage)
+ elif error.is_CollectionOfErrors:
+ return CollectionOfErrors(
+ message=_dafny.string_of(error.message),
+ list=[_deserialize_error(dafny_e) for dafny_e in error.list],
+ )
+ elif error.is_StructuredEncryptionException:
+ return StructuredEncryptionException(message=_dafny.string_of(error.message))
+ elif error.is_AwsCryptographyPrimitives:
+ return AwsCryptographicPrimitives(
+ aws_cryptography_primitives_deserialize_error(error.AwsCryptographyPrimitives)
+ )
+ elif error.is_AwsCryptographyMaterialProviders:
+ return AwsCryptographicMaterialProviders(
+ aws_cryptography_materialproviders_deserialize_error(error.AwsCryptographyMaterialProviders)
+ )
+ else:
+ return OpaqueError(obj=error)
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/errors.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/errors.py
new file mode 100644
index 000000000..dc77dce9f
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/errors.py
@@ -0,0 +1,299 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import _dafny
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_materialproviders_smithy_error_to_dafny_error,
+)
+from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.errors import (
+ _smithy_error_to_dafny_error as aws_cryptography_primitives_smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.errors
+from typing import Any, Dict, Generic, List, Literal, TypeVar
+
+
+class ServiceError(Exception):
+ """Base error for all errors in the service."""
+
+ pass
+
+
+T = TypeVar("T")
+
+
+class ApiError(ServiceError, Generic[T]):
+ """Base error for all api errors in the service."""
+
+ code: T
+
+ def __init__(self, message: str):
+ super().__init__(message)
+ self.message = message
+
+
+class UnknownApiError(ApiError[Literal["Unknown"]]):
+ """Error representing any unknown api errors."""
+
+ code: Literal["Unknown"] = "Unknown"
+
+
+class StructuredEncryptionException(ApiError[Literal["StructuredEncryptionException"]]):
+ code: Literal["StructuredEncryptionException"] = "StructuredEncryptionException"
+ message: str
+
+ def __init__(
+ self,
+ *,
+ message: str,
+ ):
+ super().__init__(message)
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the StructuredEncryptionException to a dictionary."""
+ return {
+ "message": self.message,
+ "code": self.code,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "StructuredEncryptionException":
+ """Creates a StructuredEncryptionException from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ }
+
+ return StructuredEncryptionException(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "StructuredEncryptionException("
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, StructuredEncryptionException):
+ return False
+ attributes: list[str] = [
+ "message",
+ "message",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class StructuredEncryptionException(ApiError[Literal["StructuredEncryptionException"]]):
+ code: Literal["StructuredEncryptionException"] = "StructuredEncryptionException"
+ message: str
+
+
+class AwsCryptographicPrimitives(ApiError[Literal["AwsCryptographicPrimitives"]]):
+ AwsCryptographicPrimitives: Any
+
+
+class AwsCryptographicMaterialProviders(ApiError[Literal["AwsCryptographicMaterialProviders"]]):
+ AwsCryptographicMaterialProviders: Any
+
+
+class CollectionOfErrors(ApiError[Literal["CollectionOfErrors"]]):
+ code: Literal["CollectionOfErrors"] = "CollectionOfErrors"
+ message: str
+ list: List[ServiceError]
+
+ def __init__(self, *, message: str, list):
+ super().__init__(message)
+ self.list = list
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CollectionOfErrors to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "list": self.list,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CollectionOfErrors":
+ """Creates a CollectionOfErrors from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "list": d["list"]}
+
+ return CollectionOfErrors(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CollectionOfErrors("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"list={self.list}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CollectionOfErrors):
+ return False
+ if not (self.list == other.list):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueError(ApiError[Literal["OpaqueError"]]):
+ code: Literal["OpaqueError"] = "OpaqueError"
+ obj: Any # As an OpaqueError, type of obj is unknown
+
+ def __init__(self, *, obj):
+ super().__init__("")
+ self.obj = obj
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueError":
+ """Creates a OpaqueError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {"message": d["message"], "obj": d["obj"]}
+
+ return OpaqueError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class OpaqueWithTextError(ApiError[Literal["OpaqueWithTextError"]]):
+ code: Literal["OpaqueWithTextError"] = "OpaqueWithTextError"
+ obj: Any # As an OpaqueWithTextError, type of obj is unknown
+ obj_message: str # obj_message is a message representing the details of obj
+
+ def __init__(self, *, obj, obj_message):
+ super().__init__("")
+ self.obj = obj
+ self.obj_message = obj_message
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the OpaqueWithTextError to a dictionary.
+
+ The dictionary uses the modeled shape names rather than the
+ parameter names as keys to be mostly compatible with boto3.
+ """
+ return {
+ "message": self.message,
+ "code": self.code,
+ "obj": self.obj,
+ "obj_message": self.obj_message,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "OpaqueWithTextError":
+ """Creates a OpaqueWithTextError from a dictionary.
+
+ The dictionary is expected to use the modeled shape names rather
+ than the parameter names as keys to be mostly compatible with
+ boto3.
+ """
+ kwargs: Dict[str, Any] = {
+ "message": d["message"],
+ "obj": d["obj"],
+ "obj_message": d["obj_message"],
+ }
+
+ return OpaqueWithTextError(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "OpaqueWithTextError("
+ result += f"message={self.message},"
+ if self.message is not None:
+ result += f"message={repr(self.message)}"
+ result += f"obj={self.obj}"
+ result += f"obj_message={self.obj_message}"
+ result += ")"
+ return result
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, OpaqueWithTextError):
+ return False
+ if not (self.obj == other.obj):
+ return False
+ attributes: list[str] = ["message", "message"]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _smithy_error_to_dafny_error(e: ServiceError):
+ """Converts the provided native Smithy-modeled error into the corresponding
+ Dafny error."""
+ if isinstance(
+ e,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.errors.StructuredEncryptionException,
+ ):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_StructuredEncryptionException(
+ message=_dafny.Seq(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicPrimitives):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_AwsCryptographyPrimitives(
+ aws_cryptography_primitives_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, AwsCryptographicMaterialProviders):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_AwsCryptographyMaterialProviders(
+ aws_cryptography_materialproviders_smithy_error_to_dafny_error(e.message)
+ )
+
+ if isinstance(e, CollectionOfErrors):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_CollectionOfErrors(
+ message=_dafny.Seq(e.message),
+ list=_dafny.Seq(_smithy_error_to_dafny_error(native_err) for native_err in e.list),
+ )
+
+ if isinstance(e, OpaqueError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_Opaque(
+ obj=e.obj
+ )
+
+ if isinstance(e, OpaqueWithTextError):
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_OpaqueWithText(
+ obj=e.obj, objMessage=e.obj_message
+ )
+
+ else:
+ return aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes.Error_Opaque(
+ obj=e
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/models.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/models.py
new file mode 100644
index 000000000..4ba2c8b40
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/models.py
@@ -0,0 +1,1096 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references
+from typing import Any, Dict, List, Optional, Union
+
+from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.models import (
+ EncryptedDataKey,
+)
+
+
+class AuthenticateAction:
+ SIGN = "SIGN"
+
+ DO_NOT_SIGN = "DO_NOT_SIGN"
+
+ # This set contains every possible value known at the time this was generated. New
+ # values may be added in the future.
+ values = frozenset({"SIGN", "DO_NOT_SIGN"})
+
+
+class StructuredDataTerminal:
+ value: bytes | bytearray
+ type_id: bytes | bytearray
+
+ def __init__(
+ self,
+ *,
+ value: bytes | bytearray,
+ type_id: bytes | bytearray,
+ ):
+ self.value = value
+ if (type_id is not None) and (len(type_id) < 2):
+ raise ValueError("The size of type_id must be greater than or equal to 2")
+
+ if (type_id is not None) and (len(type_id) > 2):
+ raise ValueError("The size of type_id must be less than or equal to 2")
+
+ self.type_id = type_id
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the StructuredDataTerminal to a dictionary."""
+ return {
+ "value": self.value,
+ "type_id": self.type_id,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "StructuredDataTerminal":
+ """Creates a StructuredDataTerminal from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "value": d["value"],
+ "type_id": d["type_id"],
+ }
+
+ return StructuredDataTerminal(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "StructuredDataTerminal("
+ if self.value is not None:
+ result += f"value={repr(self.value)}, "
+
+ if self.type_id is not None:
+ result += f"type_id={repr(self.type_id)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, StructuredDataTerminal):
+ return False
+ attributes: list[str] = [
+ "value",
+ "type_id",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class StructureSegment:
+ key: str
+
+ def __init__(
+ self,
+ *,
+ key: str,
+ ):
+ self.key = key
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the StructureSegment to a dictionary."""
+ return {
+ "key": self.key,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "StructureSegment":
+ """Creates a StructureSegment from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key": d["key"],
+ }
+
+ return StructureSegment(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "StructureSegment("
+ if self.key is not None:
+ result += f"key={repr(self.key)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, StructureSegment):
+ return False
+ attributes: list[str] = [
+ "key",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class PathSegmentMember:
+ def __init__(self, value: StructureSegment):
+ self.value = value
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"member": self.value.as_dict()}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PathSegmentMember":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+ return PathSegmentMember(StructureSegment.from_dict(d["member"]))
+
+ def __repr__(self) -> str:
+ return f"PathSegmentMember(value=repr(self.value))"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, PathSegmentMember):
+ return False
+ return self.value == other.value
+
+
+class PathSegmentUnknown:
+ """Represents an unknown variant.
+
+ If you receive this value, you will need to update your library to
+ receive the parsed value.
+
+ This value may not be deliberately sent.
+ """
+
+ def __init__(self, tag: str):
+ self.tag = tag
+
+ def as_dict(self) -> Dict[str, Any]:
+ return {"SDK_UNKNOWN_MEMBER": {"name": self.tag}}
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "PathSegmentUnknown":
+ if len(d) != 1:
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+ return PathSegmentUnknown(d["SDK_UNKNOWN_MEMBER"]["name"])
+
+ def __repr__(self) -> str:
+ return f"PathSegmentUnknown(tag={self.tag})"
+
+
+PathSegment = Union[PathSegmentMember, PathSegmentUnknown]
+
+
+def _path_segment_from_dict(d: Dict[str, Any]) -> PathSegment:
+ if "member" in d:
+ return PathSegmentMember.from_dict(d)
+
+ raise TypeError(f"Unions may have exactly 1 value, but found {len(d)}")
+
+
+class AuthItem:
+ key: list[PathSegment]
+ data: StructuredDataTerminal
+ action: str
+
+ def __init__(
+ self,
+ *,
+ key: list[PathSegment],
+ data: StructuredDataTerminal,
+ action: str,
+ ):
+ self.key = key
+ self.data = data
+ self.action = action
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the AuthItem to a dictionary."""
+ return {
+ "key": _path_as_dict(self.key),
+ "data": self.data.as_dict(),
+ "action": self.action,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "AuthItem":
+ """Creates a AuthItem from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key": _path_from_dict(d["key"]),
+ "data": StructuredDataTerminal.from_dict(d["data"]),
+ "action": d["action"],
+ }
+
+ return AuthItem(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "AuthItem("
+ if self.key is not None:
+ result += f"key={repr(self.key)}, "
+
+ if self.data is not None:
+ result += f"data={repr(self.data)}, "
+
+ if self.action is not None:
+ result += f"action={repr(self.action)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, AuthItem):
+ return False
+ attributes: list[str] = [
+ "key",
+ "data",
+ "action",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class CryptoAction:
+ ENCRYPT_AND_SIGN = "ENCRYPT_AND_SIGN"
+
+ SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT = "SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT"
+
+ SIGN_ONLY = "SIGN_ONLY"
+
+ DO_NOTHING = "DO_NOTHING"
+
+ # This set contains every possible value known at the time this was generated. New
+ # values may be added in the future.
+ values = frozenset(
+ {
+ "ENCRYPT_AND_SIGN",
+ "SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT",
+ "SIGN_ONLY",
+ "DO_NOTHING",
+ }
+ )
+
+
+class CryptoItem:
+ key: list[PathSegment]
+ data: StructuredDataTerminal
+ action: str
+
+ def __init__(
+ self,
+ *,
+ key: list[PathSegment],
+ data: StructuredDataTerminal,
+ action: str,
+ ):
+ self.key = key
+ self.data = data
+ self.action = action
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the CryptoItem to a dictionary."""
+ return {
+ "key": _path_as_dict(self.key),
+ "data": self.data.as_dict(),
+ "action": self.action,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "CryptoItem":
+ """Creates a CryptoItem from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "key": _path_from_dict(d["key"]),
+ "data": StructuredDataTerminal.from_dict(d["data"]),
+ "action": d["action"],
+ }
+
+ return CryptoItem(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "CryptoItem("
+ if self.key is not None:
+ result += f"key={repr(self.key)}, "
+
+ if self.data is not None:
+ result += f"data={repr(self.data)}, "
+
+ if self.action is not None:
+ result += f"action={repr(self.action)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, CryptoItem):
+ return False
+ attributes: list[str] = [
+ "key",
+ "data",
+ "action",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DecryptPathStructureInput:
+ table_name: str
+ encrypted_structure: list[AuthItem]
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ encryption_context: Optional[dict[str, str]]
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ encrypted_structure: list[AuthItem],
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager",
+ encryption_context: Optional[dict[str, str]] = None,
+ ):
+ self.table_name = table_name
+ self.encrypted_structure = encrypted_structure
+ self.cmm = cmm
+ self.encryption_context = encryption_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptPathStructureInput to a dictionary."""
+ d: Dict[str, Any] = {
+ "table_name": self.table_name,
+ "encrypted_structure": _auth_list_as_dict(self.encrypted_structure),
+ "cmm": self.cmm.as_dict(),
+ }
+
+ if self.encryption_context is not None:
+ d["encryption_context"] = self.encryption_context
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptPathStructureInput":
+ """Creates a DecryptPathStructureInput from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "encrypted_structure": _auth_list_from_dict(d["encrypted_structure"]),
+ "cmm": CryptographicMaterialsManager.from_dict(d["cmm"]),
+ }
+
+ if "encryption_context" in d:
+ kwargs["encryption_context"] = d["encryption_context"]
+
+ return DecryptPathStructureInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptPathStructureInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.encrypted_structure is not None:
+ result += f"encrypted_structure={repr(self.encrypted_structure)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptPathStructureInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "encrypted_structure",
+ "cmm",
+ "encryption_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ParsedHeader:
+ algorithm_suite_id: str
+ encrypted_data_keys: list[EncryptedDataKey]
+ stored_encryption_context: dict[str, str]
+ encryption_context: dict[str, str]
+
+ def __init__(
+ self,
+ *,
+ algorithm_suite_id: str,
+ encrypted_data_keys: list[EncryptedDataKey],
+ stored_encryption_context: dict[str, str],
+ encryption_context: dict[str, str],
+ ):
+ self.algorithm_suite_id = algorithm_suite_id
+ self.encrypted_data_keys = encrypted_data_keys
+ self.stored_encryption_context = stored_encryption_context
+ self.encryption_context = encryption_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ParsedHeader to a dictionary."""
+ return {
+ "algorithm_suite_id": self.algorithm_suite_id,
+ "encrypted_data_keys": self.encrypted_data_keys,
+ "stored_encryption_context": self.stored_encryption_context,
+ "encryption_context": self.encryption_context,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ParsedHeader":
+ """Creates a ParsedHeader from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "algorithm_suite_id": d["algorithm_suite_id"],
+ "encrypted_data_keys": d["encrypted_data_keys"],
+ "stored_encryption_context": d["stored_encryption_context"],
+ "encryption_context": d["encryption_context"],
+ }
+
+ return ParsedHeader(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ParsedHeader("
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.encrypted_data_keys is not None:
+ result += f"encrypted_data_keys={repr(self.encrypted_data_keys)}, "
+
+ if self.stored_encryption_context is not None:
+ result += f"stored_encryption_context={repr(self.stored_encryption_context)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ParsedHeader):
+ return False
+ attributes: list[str] = [
+ "algorithm_suite_id",
+ "encrypted_data_keys",
+ "stored_encryption_context",
+ "encryption_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DecryptPathStructureOutput:
+ plaintext_structure: list[CryptoItem]
+ parsed_header: ParsedHeader
+
+ def __init__(
+ self,
+ *,
+ plaintext_structure: list[CryptoItem],
+ parsed_header: ParsedHeader,
+ ):
+ self.plaintext_structure = plaintext_structure
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptPathStructureOutput to a dictionary."""
+ return {
+ "plaintext_structure": _crypto_list_as_dict(self.plaintext_structure),
+ "parsed_header": self.parsed_header.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptPathStructureOutput":
+ """Creates a DecryptPathStructureOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "plaintext_structure": _crypto_list_from_dict(d["plaintext_structure"]),
+ "parsed_header": ParsedHeader.from_dict(d["parsed_header"]),
+ }
+
+ return DecryptPathStructureOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptPathStructureOutput("
+ if self.plaintext_structure is not None:
+ result += f"plaintext_structure={repr(self.plaintext_structure)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptPathStructureOutput):
+ return False
+ attributes: list[str] = [
+ "plaintext_structure",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DecryptStructureInput:
+ table_name: str
+ encrypted_structure: dict[str, StructuredDataTerminal]
+ authenticate_schema: dict[str, str]
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ encryption_context: Optional[dict[str, str]]
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ encrypted_structure: dict[str, StructuredDataTerminal],
+ authenticate_schema: dict[str, str],
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager",
+ encryption_context: Optional[dict[str, str]] = None,
+ ):
+ self.table_name = table_name
+ self.encrypted_structure = encrypted_structure
+ self.authenticate_schema = authenticate_schema
+ self.cmm = cmm
+ self.encryption_context = encryption_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptStructureInput to a dictionary."""
+ d: Dict[str, Any] = {
+ "table_name": self.table_name,
+ "encrypted_structure": _structured_data_map_as_dict(self.encrypted_structure),
+ "authenticate_schema": self.authenticate_schema,
+ "cmm": self.cmm.as_dict(),
+ }
+
+ if self.encryption_context is not None:
+ d["encryption_context"] = self.encryption_context
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptStructureInput":
+ """Creates a DecryptStructureInput from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "encrypted_structure": _structured_data_map_from_dict(d["encrypted_structure"]),
+ "authenticate_schema": d["authenticate_schema"],
+ "cmm": CryptographicMaterialsManager.from_dict(d["cmm"]),
+ }
+
+ if "encryption_context" in d:
+ kwargs["encryption_context"] = d["encryption_context"]
+
+ return DecryptStructureInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptStructureInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.encrypted_structure is not None:
+ result += f"encrypted_structure={repr(self.encrypted_structure)}, "
+
+ if self.authenticate_schema is not None:
+ result += f"authenticate_schema={repr(self.authenticate_schema)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptStructureInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "encrypted_structure",
+ "authenticate_schema",
+ "cmm",
+ "encryption_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class DecryptStructureOutput:
+ plaintext_structure: dict[str, StructuredDataTerminal]
+ crypto_schema: dict[str, str]
+ parsed_header: ParsedHeader
+
+ def __init__(
+ self,
+ *,
+ plaintext_structure: dict[str, StructuredDataTerminal],
+ crypto_schema: dict[str, str],
+ parsed_header: ParsedHeader,
+ ):
+ self.plaintext_structure = plaintext_structure
+ self.crypto_schema = crypto_schema
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the DecryptStructureOutput to a dictionary."""
+ return {
+ "plaintext_structure": _structured_data_map_as_dict(self.plaintext_structure),
+ "crypto_schema": self.crypto_schema,
+ "parsed_header": self.parsed_header.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "DecryptStructureOutput":
+ """Creates a DecryptStructureOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "plaintext_structure": _structured_data_map_from_dict(d["plaintext_structure"]),
+ "crypto_schema": d["crypto_schema"],
+ "parsed_header": ParsedHeader.from_dict(d["parsed_header"]),
+ }
+
+ return DecryptStructureOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "DecryptStructureOutput("
+ if self.plaintext_structure is not None:
+ result += f"plaintext_structure={repr(self.plaintext_structure)}, "
+
+ if self.crypto_schema is not None:
+ result += f"crypto_schema={repr(self.crypto_schema)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, DecryptStructureOutput):
+ return False
+ attributes: list[str] = [
+ "plaintext_structure",
+ "crypto_schema",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptPathStructureInput:
+ table_name: str
+ plaintext_structure: list[CryptoItem]
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ algorithm_suite_id: Optional[str]
+ encryption_context: Optional[dict[str, str]]
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ plaintext_structure: list[CryptoItem],
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager",
+ algorithm_suite_id: Optional[str] = None,
+ encryption_context: Optional[dict[str, str]] = None,
+ ):
+ self.table_name = table_name
+ self.plaintext_structure = plaintext_structure
+ self.cmm = cmm
+ self.algorithm_suite_id = algorithm_suite_id
+ self.encryption_context = encryption_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptPathStructureInput to a dictionary."""
+ d: Dict[str, Any] = {
+ "table_name": self.table_name,
+ "plaintext_structure": _crypto_list_as_dict(self.plaintext_structure),
+ "cmm": self.cmm.as_dict(),
+ }
+
+ if self.algorithm_suite_id is not None:
+ d["algorithm_suite_id"] = self.algorithm_suite_id
+
+ if self.encryption_context is not None:
+ d["encryption_context"] = self.encryption_context
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptPathStructureInput":
+ """Creates a EncryptPathStructureInput from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "plaintext_structure": _crypto_list_from_dict(d["plaintext_structure"]),
+ "cmm": CryptographicMaterialsManager.from_dict(d["cmm"]),
+ }
+
+ if "algorithm_suite_id" in d:
+ kwargs["algorithm_suite_id"] = d["algorithm_suite_id"]
+
+ if "encryption_context" in d:
+ kwargs["encryption_context"] = d["encryption_context"]
+
+ return EncryptPathStructureInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptPathStructureInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.plaintext_structure is not None:
+ result += f"plaintext_structure={repr(self.plaintext_structure)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptPathStructureInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "plaintext_structure",
+ "cmm",
+ "algorithm_suite_id",
+ "encryption_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptPathStructureOutput:
+ encrypted_structure: list[CryptoItem]
+ parsed_header: ParsedHeader
+
+ def __init__(
+ self,
+ *,
+ encrypted_structure: list[CryptoItem],
+ parsed_header: ParsedHeader,
+ ):
+ self.encrypted_structure = encrypted_structure
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptPathStructureOutput to a dictionary."""
+ return {
+ "encrypted_structure": _crypto_list_as_dict(self.encrypted_structure),
+ "parsed_header": self.parsed_header.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptPathStructureOutput":
+ """Creates a EncryptPathStructureOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "encrypted_structure": _crypto_list_from_dict(d["encrypted_structure"]),
+ "parsed_header": ParsedHeader.from_dict(d["parsed_header"]),
+ }
+
+ return EncryptPathStructureOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptPathStructureOutput("
+ if self.encrypted_structure is not None:
+ result += f"encrypted_structure={repr(self.encrypted_structure)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptPathStructureOutput):
+ return False
+ attributes: list[str] = [
+ "encrypted_structure",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptStructureInput:
+ table_name: str
+ plaintext_structure: dict[str, StructuredDataTerminal]
+ crypto_schema: dict[str, str]
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager"
+ algorithm_suite_id: Optional[str]
+ encryption_context: Optional[dict[str, str]]
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ plaintext_structure: dict[str, StructuredDataTerminal],
+ crypto_schema: dict[str, str],
+ cmm: "aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references.CryptographicMaterialsManager",
+ algorithm_suite_id: Optional[str] = None,
+ encryption_context: Optional[dict[str, str]] = None,
+ ):
+ self.table_name = table_name
+ self.plaintext_structure = plaintext_structure
+ self.crypto_schema = crypto_schema
+ self.cmm = cmm
+ self.algorithm_suite_id = algorithm_suite_id
+ self.encryption_context = encryption_context
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptStructureInput to a dictionary."""
+ d: Dict[str, Any] = {
+ "table_name": self.table_name,
+ "plaintext_structure": _structured_data_map_as_dict(self.plaintext_structure),
+ "crypto_schema": self.crypto_schema,
+ "cmm": self.cmm.as_dict(),
+ }
+
+ if self.algorithm_suite_id is not None:
+ d["algorithm_suite_id"] = self.algorithm_suite_id
+
+ if self.encryption_context is not None:
+ d["encryption_context"] = self.encryption_context
+
+ return d
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptStructureInput":
+ """Creates a EncryptStructureInput from a dictionary."""
+ from aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.references import (
+ CryptographicMaterialsManager,
+ )
+
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "plaintext_structure": _structured_data_map_from_dict(d["plaintext_structure"]),
+ "crypto_schema": d["crypto_schema"],
+ "cmm": CryptographicMaterialsManager.from_dict(d["cmm"]),
+ }
+
+ if "algorithm_suite_id" in d:
+ kwargs["algorithm_suite_id"] = d["algorithm_suite_id"]
+
+ if "encryption_context" in d:
+ kwargs["encryption_context"] = d["encryption_context"]
+
+ return EncryptStructureInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptStructureInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.plaintext_structure is not None:
+ result += f"plaintext_structure={repr(self.plaintext_structure)}, "
+
+ if self.crypto_schema is not None:
+ result += f"crypto_schema={repr(self.crypto_schema)}, "
+
+ if self.cmm is not None:
+ result += f"cmm={repr(self.cmm)}, "
+
+ if self.algorithm_suite_id is not None:
+ result += f"algorithm_suite_id={repr(self.algorithm_suite_id)}, "
+
+ if self.encryption_context is not None:
+ result += f"encryption_context={repr(self.encryption_context)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptStructureInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "plaintext_structure",
+ "crypto_schema",
+ "cmm",
+ "algorithm_suite_id",
+ "encryption_context",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class EncryptStructureOutput:
+ encrypted_structure: dict[str, StructuredDataTerminal]
+ crypto_schema: dict[str, str]
+ parsed_header: ParsedHeader
+
+ def __init__(
+ self,
+ *,
+ encrypted_structure: dict[str, StructuredDataTerminal],
+ crypto_schema: dict[str, str],
+ parsed_header: ParsedHeader,
+ ):
+ self.encrypted_structure = encrypted_structure
+ self.crypto_schema = crypto_schema
+ self.parsed_header = parsed_header
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the EncryptStructureOutput to a dictionary."""
+ return {
+ "encrypted_structure": _structured_data_map_as_dict(self.encrypted_structure),
+ "crypto_schema": self.crypto_schema,
+ "parsed_header": self.parsed_header.as_dict(),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "EncryptStructureOutput":
+ """Creates a EncryptStructureOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "encrypted_structure": _structured_data_map_from_dict(d["encrypted_structure"]),
+ "crypto_schema": d["crypto_schema"],
+ "parsed_header": ParsedHeader.from_dict(d["parsed_header"]),
+ }
+
+ return EncryptStructureOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "EncryptStructureOutput("
+ if self.encrypted_structure is not None:
+ result += f"encrypted_structure={repr(self.encrypted_structure)}, "
+
+ if self.crypto_schema is not None:
+ result += f"crypto_schema={repr(self.crypto_schema)}, "
+
+ if self.parsed_header is not None:
+ result += f"parsed_header={repr(self.parsed_header)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, EncryptStructureOutput):
+ return False
+ attributes: list[str] = [
+ "encrypted_structure",
+ "crypto_schema",
+ "parsed_header",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ResolveAuthActionsInput:
+ table_name: str
+ auth_actions: list[AuthItem]
+ header_bytes: bytes | bytearray
+
+ def __init__(
+ self,
+ *,
+ table_name: str,
+ auth_actions: list[AuthItem],
+ header_bytes: bytes | bytearray,
+ ):
+ self.table_name = table_name
+ self.auth_actions = auth_actions
+ self.header_bytes = header_bytes
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ResolveAuthActionsInput to a dictionary."""
+ return {
+ "table_name": self.table_name,
+ "auth_actions": _auth_list_as_dict(self.auth_actions),
+ "header_bytes": self.header_bytes,
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ResolveAuthActionsInput":
+ """Creates a ResolveAuthActionsInput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "table_name": d["table_name"],
+ "auth_actions": _auth_list_from_dict(d["auth_actions"]),
+ "header_bytes": d["header_bytes"],
+ }
+
+ return ResolveAuthActionsInput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ResolveAuthActionsInput("
+ if self.table_name is not None:
+ result += f"table_name={repr(self.table_name)}, "
+
+ if self.auth_actions is not None:
+ result += f"auth_actions={repr(self.auth_actions)}, "
+
+ if self.header_bytes is not None:
+ result += f"header_bytes={repr(self.header_bytes)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ResolveAuthActionsInput):
+ return False
+ attributes: list[str] = [
+ "table_name",
+ "auth_actions",
+ "header_bytes",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+class ResolveAuthActionsOutput:
+ crypto_actions: list[CryptoItem]
+
+ def __init__(
+ self,
+ *,
+ crypto_actions: list[CryptoItem],
+ ):
+ self.crypto_actions = crypto_actions
+
+ def as_dict(self) -> Dict[str, Any]:
+ """Converts the ResolveAuthActionsOutput to a dictionary."""
+ return {
+ "crypto_actions": _crypto_list_as_dict(self.crypto_actions),
+ }
+
+ @staticmethod
+ def from_dict(d: Dict[str, Any]) -> "ResolveAuthActionsOutput":
+ """Creates a ResolveAuthActionsOutput from a dictionary."""
+ kwargs: Dict[str, Any] = {
+ "crypto_actions": _crypto_list_from_dict(d["crypto_actions"]),
+ }
+
+ return ResolveAuthActionsOutput(**kwargs)
+
+ def __repr__(self) -> str:
+ result = "ResolveAuthActionsOutput("
+ if self.crypto_actions is not None:
+ result += f"crypto_actions={repr(self.crypto_actions)}"
+
+ return result + ")"
+
+ def __eq__(self, other: Any) -> bool:
+ if not isinstance(other, ResolveAuthActionsOutput):
+ return False
+ attributes: list[str] = [
+ "crypto_actions",
+ ]
+ return all(getattr(self, a) == getattr(other, a) for a in attributes)
+
+
+def _crypto_list_as_dict(given: list[CryptoItem]) -> List[Any]:
+ return [v.as_dict() for v in given]
+
+
+def _crypto_list_from_dict(given: List[Any]) -> list[CryptoItem]:
+ return [CryptoItem.from_dict(v) for v in given]
+
+
+def _path_as_dict(given: list[PathSegment]) -> List[Any]:
+ return [v.as_dict() for v in given]
+
+
+def _path_from_dict(given: List[Any]) -> list[PathSegment]:
+ return [PathSegment.from_dict(v) for v in given]
+
+
+def _auth_list_as_dict(given: list[AuthItem]) -> List[Any]:
+ return [v.as_dict() for v in given]
+
+
+def _auth_list_from_dict(given: List[Any]) -> list[AuthItem]:
+ return [AuthItem.from_dict(v) for v in given]
+
+
+def _structured_data_map_as_dict(
+ given: dict[str, StructuredDataTerminal],
+) -> Dict[str, Any]:
+ return {k: v.as_dict() for k, v in given.items()}
+
+
+def _structured_data_map_from_dict(
+ given: Dict[str, Any],
+) -> dict[str, StructuredDataTerminal]:
+ return {k: StructuredDataTerminal.from_dict(v) for k, v in given.items()}
+
+
+class Unit:
+ pass
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/plugin.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/plugin.py
new file mode 100644
index 000000000..f7ff755c3
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/plugin.py
@@ -0,0 +1,49 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from .config import (
+ Config,
+ Plugin,
+ smithy_config_to_dafny_config,
+ StructuredEncryptionConfig,
+)
+from smithy_python.interfaces.retries import RetryStrategy
+from smithy_python.exceptions import SmithyRetryException
+from .dafnyImplInterface import DafnyImplInterface
+
+
+def set_config_impl(config: Config):
+ """Set the Dafny-compiled implementation in the Smithy-Python client Config
+ and load our custom NoRetriesStrategy."""
+ config.dafnyImplInterface = DafnyImplInterface()
+ if isinstance(config, StructuredEncryptionConfig):
+ from aws_dbesdk_dynamodb.internaldafny.generated.StructuredEncryption import (
+ default__,
+ )
+
+ config.dafnyImplInterface.impl = default__.StructuredEncryption(smithy_config_to_dafny_config(config)).value
+ config.retry_strategy = NoRetriesStrategy()
+
+
+class ZeroRetryDelayToken:
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not wait to retry.
+ """
+
+ retry_delay = 0
+
+
+class NoRetriesStrategy(RetryStrategy):
+ """Placeholder class required by Smithy-Python client implementation.
+
+ Do not retry calling Dafny code.
+ """
+
+ def acquire_initial_retry_token(self):
+ return ZeroRetryDelayToken()
+
+ def refresh_retry_token_for_retry(self, token_to_renew, error_info):
+ # Do not retry
+ raise SmithyRetryException()
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/serialize.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/serialize.py
new file mode 100644
index 000000000..6b0353e08
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/serialize.py
@@ -0,0 +1,54 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny
+
+from .dafny_protocol import DafnyRequest
+
+from .config import Config
+
+
+def _serialize_encrypt_structure(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="EncryptStructure",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureInput(
+ input
+ ),
+ )
+
+
+def _serialize_decrypt_structure(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="DecryptStructure",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureInput(
+ input
+ ),
+ )
+
+
+def _serialize_encrypt_path_structure(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="EncryptPathStructure",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureInput(
+ input
+ ),
+ )
+
+
+def _serialize_decrypt_path_structure(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="DecryptPathStructure",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureInput(
+ input
+ ),
+ )
+
+
+def _serialize_resolve_auth_actions(input, config: Config) -> DafnyRequest:
+ return DafnyRequest(
+ operation_name="ResolveAuthActions",
+ dafny_operation_input=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsInput(
+ input
+ ),
+ )
diff --git a/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/smithy_to_dafny.py b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/smithy_to_dafny.py
new file mode 100644
index 000000000..6bf97c976
--- /dev/null
+++ b/DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_structuredencryption/smithy_to_dafny.py
@@ -0,0 +1,524 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from _dafny import Map, Seq
+import aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkStructuredEncryptionTypes import (
+ AuthItem_AuthItem as DafnyAuthItem,
+ AuthenticateAction_DO__NOT__SIGN,
+ AuthenticateAction_SIGN,
+ CryptoAction_DO__NOTHING,
+ CryptoAction_ENCRYPT__AND__SIGN,
+ CryptoAction_SIGN__AND__INCLUDE__IN__ENCRYPTION__CONTEXT,
+ CryptoAction_SIGN__ONLY,
+ CryptoItem_CryptoItem as DafnyCryptoItem,
+ DecryptPathStructureInput_DecryptPathStructureInput as DafnyDecryptPathStructureInput,
+ DecryptPathStructureOutput_DecryptPathStructureOutput as DafnyDecryptPathStructureOutput,
+ DecryptStructureInput_DecryptStructureInput as DafnyDecryptStructureInput,
+ DecryptStructureOutput_DecryptStructureOutput as DafnyDecryptStructureOutput,
+ EncryptPathStructureInput_EncryptPathStructureInput as DafnyEncryptPathStructureInput,
+ EncryptPathStructureOutput_EncryptPathStructureOutput as DafnyEncryptPathStructureOutput,
+ EncryptStructureInput_EncryptStructureInput as DafnyEncryptStructureInput,
+ EncryptStructureOutput_EncryptStructureOutput as DafnyEncryptStructureOutput,
+ ParsedHeader_ParsedHeader as DafnyParsedHeader,
+ PathSegment_member,
+ ResolveAuthActionsInput_ResolveAuthActionsInput as DafnyResolveAuthActionsInput,
+ ResolveAuthActionsOutput_ResolveAuthActionsOutput as DafnyResolveAuthActionsOutput,
+ StructureSegment_StructureSegment as DafnyStructureSegment,
+ StructuredDataTerminal_StructuredDataTerminal as DafnyStructuredDataTerminal,
+ StructuredEncryptionConfig_StructuredEncryptionConfig as DafnyStructuredEncryptionConfig,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny
+from smithy_dafny_standard_library.internaldafny.generated.Wrappers import (
+ Option_None,
+ Option_Some,
+)
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureInput(
+ native_input,
+):
+ return DafnyEncryptStructureInput(
+ tableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ plaintextStructure=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in native_input.plaintext_structure.items()
+ }
+ ),
+ cryptoSchema=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.crypto_schema.items()
+ }
+ ),
+ cmm=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ ),
+ algorithmSuiteId=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ )
+ )
+ )
+ if (native_input.algorithm_suite_id is not None)
+ else (Option_None())
+ ),
+ encryptionContext=(
+ (
+ Option_Some(
+ Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ )
+ )
+ )
+ if (native_input.encryption_context is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ native_input,
+):
+ return DafnyStructuredDataTerminal(
+ value=Seq(native_input.value),
+ typeId=Seq(native_input.type_id),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(native_input):
+ if native_input == "ENCRYPT_AND_SIGN":
+ return CryptoAction_ENCRYPT__AND__SIGN()
+
+ elif native_input == "SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT":
+ return CryptoAction_SIGN__AND__INCLUDE__IN__ENCRYPTION__CONTEXT()
+
+ elif native_input == "SIGN_ONLY":
+ return CryptoAction_SIGN__ONLY()
+
+ elif native_input == "DO_NOTHING":
+ return CryptoAction_DO__NOTHING()
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {native_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureInput(
+ native_input,
+):
+ return DafnyDecryptStructureInput(
+ tableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ encryptedStructure=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in native_input.encrypted_structure.items()
+ }
+ ),
+ authenticateSchema=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ value
+ )
+ for (key, value) in native_input.authenticate_schema.items()
+ }
+ ),
+ cmm=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ ),
+ encryptionContext=(
+ (
+ Option_Some(
+ Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ )
+ )
+ )
+ if (native_input.encryption_context is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ native_input,
+):
+ if native_input == "SIGN":
+ return AuthenticateAction_SIGN()
+
+ elif native_input == "DO_NOT_SIGN":
+ return AuthenticateAction_DO__NOT__SIGN()
+
+ else:
+ raise ValueError(f"No recognized enum value in enum type: {native_input=}")
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureInput(
+ native_input,
+):
+ return DafnyEncryptPathStructureInput(
+ tableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ plaintextStructure=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in native_input.plaintext_structure
+ ]
+ ),
+ cmm=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ ),
+ algorithmSuiteId=(
+ (
+ Option_Some(
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ )
+ )
+ )
+ if (native_input.algorithm_suite_id is not None)
+ else (Option_None())
+ ),
+ encryptionContext=(
+ (
+ Option_Some(
+ Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ )
+ )
+ )
+ if (native_input.encryption_context is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(native_input):
+ return DafnyCryptoItem(
+ key=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(
+ list_element
+ )
+ for list_element in native_input.key
+ ]
+ ),
+ data=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ native_input.data
+ ),
+ action=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ native_input.action
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(native_input):
+ if isinstance(
+ native_input,
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.models.PathSegmentMember,
+ ):
+ PathSegment_union_value = PathSegment_member(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructureSegment(
+ native_input.value
+ )
+ )
+ else:
+ raise ValueError("No recognized union value in union type: " + str(native_input))
+
+ return PathSegment_union_value
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructureSegment(
+ native_input,
+):
+ return DafnyStructureSegment(
+ key=Seq(
+ "".join(
+ [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(native_input.key.encode("utf-16-be"))] * 2)]
+ )
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureInput(
+ native_input,
+):
+ return DafnyDecryptPathStructureInput(
+ tableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ encryptedStructure=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(
+ list_element
+ )
+ for list_element in native_input.encrypted_structure
+ ]
+ ),
+ cmm=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_CryptographicMaterialsManagerReference(
+ native_input.cmm
+ ),
+ encryptionContext=(
+ (
+ Option_Some(
+ Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ )
+ )
+ )
+ if (native_input.encryption_context is not None)
+ else (Option_None())
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(native_input):
+ return DafnyAuthItem(
+ key=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_PathSegment(
+ list_element
+ )
+ for list_element in native_input.key
+ ]
+ ),
+ data=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ native_input.data
+ ),
+ action=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_AuthenticateAction(
+ native_input.action
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsInput(
+ native_input,
+):
+ return DafnyResolveAuthActionsInput(
+ tableName=Seq(
+ "".join(
+ [
+ chr(int.from_bytes(pair, "big"))
+ for pair in zip(*[iter(native_input.table_name.encode("utf-16-be"))] * 2)
+ ]
+ )
+ ),
+ authActions=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_AuthItem(
+ list_element
+ )
+ for list_element in native_input.auth_actions
+ ]
+ ),
+ headerBytes=Seq(native_input.header_bytes),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptStructureOutput(
+ native_input,
+):
+ return DafnyEncryptStructureOutput(
+ encryptedStructure=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in native_input.encrypted_structure.items()
+ }
+ ),
+ cryptoSchema=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.crypto_schema.items()
+ }
+ ),
+ parsedHeader=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ native_input.parsed_header
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(native_input):
+ return DafnyParsedHeader(
+ algorithmSuiteId=aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_DBEAlgorithmSuiteId(
+ native_input.algorithm_suite_id
+ ),
+ encryptedDataKeys=Seq(
+ [
+ aws_cryptographic_material_providers.smithygenerated.aws_cryptography_materialproviders.smithy_to_dafny.aws_cryptography_materialproviders_EncryptedDataKey(
+ list_element
+ )
+ for list_element in native_input.encrypted_data_keys
+ ]
+ ),
+ storedEncryptionContext=Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.stored_encryption_context.items()
+ }
+ ),
+ encryptionContext=Map(
+ {
+ Seq(key.encode("utf-8")): Seq(value.encode("utf-8"))
+ for (key, value) in native_input.encryption_context.items()
+ }
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptStructureOutput(
+ native_input,
+):
+ return DafnyDecryptStructureOutput(
+ plaintextStructure=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_StructuredDataTerminal(
+ value
+ )
+ for (key, value) in native_input.plaintext_structure.items()
+ }
+ ),
+ cryptoSchema=Map(
+ {
+ Seq(
+ "".join([chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)])
+ ): aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoAction(
+ value
+ )
+ for (key, value) in native_input.crypto_schema.items()
+ }
+ ),
+ parsedHeader=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ native_input.parsed_header
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_EncryptPathStructureOutput(
+ native_input,
+):
+ return DafnyEncryptPathStructureOutput(
+ encryptedStructure=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in native_input.encrypted_structure
+ ]
+ ),
+ parsedHeader=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ native_input.parsed_header
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_DecryptPathStructureOutput(
+ native_input,
+):
+ return DafnyDecryptPathStructureOutput(
+ plaintextStructure=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in native_input.plaintext_structure
+ ]
+ ),
+ parsedHeader=aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_ParsedHeader(
+ native_input.parsed_header
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_ResolveAuthActionsOutput(
+ native_input,
+):
+ return DafnyResolveAuthActionsOutput(
+ cryptoActions=Seq(
+ [
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_structuredencryption.smithy_to_dafny.aws_cryptography_dbencryptionsdk_structuredencryption_CryptoItem(
+ list_element
+ )
+ for list_element in native_input.crypto_actions
+ ]
+ ),
+ )
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_AtomicPrimitivesReference(
+ native_input,
+):
+ return native_input._config.dafnyImplInterface.impl
+
+
+def aws_cryptography_dbencryptionsdk_structuredencryption_StructuredEncryptionConfig(
+ native_input,
+):
+ return DafnyStructuredEncryptionConfig()
diff --git a/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/shim.py b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/shim.py
new file mode 100644
index 000000000..ee4651238
--- /dev/null
+++ b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/shim.py
@@ -0,0 +1,72 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes import (
+ CreateDynamoDbEncryptionBranchKeyIdSupplierInput_CreateDynamoDbEncryptionBranchKeyIdSupplierInput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierInput,
+ CreateDynamoDbEncryptionBranchKeyIdSupplierOutput_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput as DafnyCreateDynamoDbEncryptionBranchKeyIdSupplierOutput,
+ GetEncryptedDataKeyDescriptionInput_GetEncryptedDataKeyDescriptionInput as DafnyGetEncryptedDataKeyDescriptionInput,
+ GetEncryptedDataKeyDescriptionOutput_GetEncryptedDataKeyDescriptionOutput as DafnyGetEncryptedDataKeyDescriptionOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.errors import (
+ CollectionOfErrors,
+ OpaqueError,
+ ServiceError,
+ _smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny
+from typing import Any
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.client as client_impl
+
+
+class DynamoDbEncryptionShim(
+ aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbTypes.IDynamoDbEncryptionClient
+):
+ def __init__(self, _impl: client_impl):
+ self._impl = _impl
+
+ def CreateDynamoDbEncryptionBranchKeyIdSupplier(self, input):
+ try:
+ smithy_client_request: (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.CreateDynamoDbEncryptionBranchKeyIdSupplierInput
+ ) = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierInput(
+ input
+ )
+ smithy_client_response = (
+ self._impl.create_dynamo_db_encryption_branch_key_id_supplier(
+ smithy_client_request
+ )
+ )
+ return Wrappers.Result_Success(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_CreateDynamoDbEncryptionBranchKeyIdSupplierOutput(
+ smithy_client_response
+ )
+ )
+ except Exception as e:
+ return Wrappers.Result_Failure(_smithy_error_to_dafny_error(e))
+
+ def GetEncryptedDataKeyDescription(self, input):
+ try:
+ smithy_client_request: (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.GetEncryptedDataKeyDescriptionInput
+ ) = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionInput(
+ input
+ )
+ smithy_client_response = self._impl.get_encrypted_data_key_description(
+ smithy_client_request
+ )
+ return Wrappers.Result_Success(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_GetEncryptedDataKeyDescriptionOutput(
+ smithy_client_response
+ )
+ )
+ except Exception as e:
+ return Wrappers.Result_Failure(_smithy_error_to_dafny_error(e))
diff --git a/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py
new file mode 100644
index 000000000..09be6133b
--- /dev/null
+++ b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/__init__.py
@@ -0,0 +1,3 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
diff --git a/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/shim.py b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/shim.py
new file mode 100644
index 000000000..683f2f802
--- /dev/null
+++ b/TestVectors/runtimes/python/src/aws_dbesdk_dynamodb_test_vectors/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor/shim.py
@@ -0,0 +1,66 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Do not modify this file. This file is machine generated, and any changes to it will be overwritten.
+
+from aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes import (
+ DecryptItemInput_DecryptItemInput as DafnyDecryptItemInput,
+ DecryptItemOutput_DecryptItemOutput as DafnyDecryptItemOutput,
+ EncryptItemInput_EncryptItemInput as DafnyEncryptItemInput,
+ EncryptItemOutput_EncryptItemOutput as DafnyEncryptItemOutput,
+)
+import aws_dbesdk_dynamodb.internaldafny.generated.module_
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.errors
+from aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.errors import (
+ CollectionOfErrors,
+ OpaqueError,
+ ServiceError,
+ _smithy_error_to_dafny_error,
+)
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny
+from typing import Any
+
+
+import smithy_dafny_standard_library.internaldafny.generated.Wrappers as Wrappers
+import aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes
+import aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.client as client_impl
+
+
+class DynamoDbItemEncryptorShim(
+ aws_dbesdk_dynamodb.internaldafny.generated.AwsCryptographyDbEncryptionSdkDynamoDbItemEncryptorTypes.IDynamoDbItemEncryptorClient
+):
+ def __init__(self, _impl: client_impl):
+ self._impl = _impl
+
+ def EncryptItem(self, input):
+ try:
+ smithy_client_request: (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.EncryptItemInput
+ ) = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemInput(
+ input
+ )
+ smithy_client_response = self._impl.encrypt_item(smithy_client_request)
+ return Wrappers.Result_Success(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_EncryptItemOutput(
+ smithy_client_response
+ )
+ )
+ except Exception as e:
+ return Wrappers.Result_Failure(_smithy_error_to_dafny_error(e))
+
+ def DecryptItem(self, input):
+ try:
+ smithy_client_request: (
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.models.DecryptItemInput
+ ) = aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.dafny_to_smithy.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemInput(
+ input
+ )
+ smithy_client_response = self._impl.decrypt_item(smithy_client_request)
+ return Wrappers.Result_Success(
+ aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor.smithy_to_dafny.aws_cryptography_dbencryptionsdk_dynamodb_itemencryptor_DecryptItemOutput(
+ smithy_client_response
+ )
+ )
+ except Exception as e:
+ return Wrappers.Result_Failure(_smithy_error_to_dafny_error(e))