root
API
Generated with
root/org.encalmo.aws/AwsDynamoDbApi

AwsDynamoDbApi

org.encalmo.aws.AwsDynamoDbApi
object AwsDynamoDbApi

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type

Members list

Keywords
  • no keywords
  • case
  • inline
  • transparent

Type members

Classlikes

object AttributeUpdate

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
enum CompareFunction

DynamoDb condition function

DynamoDb condition function

  • a = b — true if the attribute a is equal to the value b
  • a < b — true if a is less than b
  • a <= b — true if a is less than or equal to b
  • a > b — true if a is greater than b
  • a >= b — true if a is greater than or equal to b
  • a BETWEEN b AND c — true if a is greater than or equal to b, and less than or equal to c.

The following function is also supported: begins_with (a, substr) — true if the value of attribute a begins with a particular substring.

Attributes

Companion
object
Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object CompareFunction

Attributes

Companion
enum
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
object Condition

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Condition.type
object DocumentPath

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
case class DynamoDbIndex(indexName: String, indexPartitionKey: (String, String), indexSortKey: Option[(String, String)], indexNonKeyAttributes: Seq[String], readCapacityUnits: Int, writeCapacityUnits: Int)

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object DynamoDbItem

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
object DynamoDbItemKey

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
object DynamoDbItemUpdate

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
object FilterCondition extends KeyConditionBuilders, ...FilterConditionBuilders

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
trait FilterConditionBuilders

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case class ItemsWithNextPage(items: Seq[DynamoDbItem], maybeNextPage: Option[() => ItemsWithNextPage])

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object KeyCondition extends KeyConditionBuilders

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
trait KeyConditionBuilders

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object KeyCondition
object ReadWriters

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
object fromBigDecimal extends Conversion[BigDecimal, AttributeValue]

Attributes

Supertypes
class Conversion[BigDecimal, AttributeValue]
trait BigDecimal => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromBoolean extends Conversion[Boolean, AttributeValue]

Attributes

Supertypes
class Conversion[Boolean, AttributeValue]
trait Boolean => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromDouble extends Conversion[Double, AttributeValue]

Attributes

Supertypes
class Conversion[Double, AttributeValue]
trait Double => AttributeValue
class Object
trait Matchable
class Any
Self type
fromDouble.type
object fromDynamoDbItem extends Conversion[DynamoDbItem, AttributeValue]

Attributes

Supertypes
class Conversion[DynamoDbItem, AttributeValue]
trait DynamoDbItem => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromInt extends Conversion[Int, AttributeValue]

Attributes

Supertypes
class Conversion[Int, AttributeValue]
trait Int => AttributeValue
class Object
trait Matchable
class Any
Self type
fromInt.type
object fromIterableOfAttributeValue extends Conversion[Iterable[AttributeValue], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[AttributeValue], AttributeValue]
trait Iterable[AttributeValue] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfBigDecimal extends Conversion[Iterable[BigDecimal], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[BigDecimal], AttributeValue]
trait Iterable[BigDecimal] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfDouble extends Conversion[Iterable[Double], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[Double], AttributeValue]
trait Iterable[Double] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfFloat extends Conversion[Iterable[Float], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[Float], AttributeValue]
trait Iterable[Float] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfInt extends Conversion[Iterable[Int], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[Int], AttributeValue]
trait Iterable[Int] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfLong extends Conversion[Iterable[Long], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[Long], AttributeValue]
trait Iterable[Long] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromIterableOfString extends Conversion[Iterable[String], AttributeValue]

Attributes

Supertypes
class Conversion[Iterable[String], AttributeValue]
trait Iterable[String] => AttributeValue
class Object
trait Matchable
class Any
Self type
object fromLong extends Conversion[Long, AttributeValue]

Attributes

Supertypes
class Conversion[Long, AttributeValue]
trait Long => AttributeValue
class Object
trait Matchable
class Any
Self type
fromLong.type
object fromString extends Conversion[String, AttributeValue]

Attributes

Supertypes
class Conversion[String, AttributeValue]
trait String => AttributeValue
class Object
trait Matchable
class Any
Self type
fromString.type
object fromValue extends Conversion[Value, AttributeValue]

Attributes

Supertypes
class Conversion[Value, AttributeValue]
trait Value => AttributeValue
class Object
trait Matchable
class Any
Self type
fromValue.type
object toUpdate extends Conversion[AttributeValue, AttributeValueUpdate]

Attributes

Supertypes
class Conversion[AttributeValue, AttributeValueUpdate]
trait AttributeValue => AttributeValueUpdate
class Object
trait Matchable
class Any
Self type
toUpdate.type

Types

type Condition = (String, CompareFunction, Seq[AttributeValue])
type DynamoDbItem = Map[String, AttributeValue]
type DynamoDbItemField = (String, AttributeValue)
type DynamoDbItemKey = Map[String, AttributeValue]
type DynamoDbItemUpdate = Map[String, AttributeValueUpdate]
type FilterCondition = Condition

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.FilterExpression.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.FilterExpression.html

Attributes

type KeyCondition = Condition

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.KeyConditionExpressions.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.KeyConditionExpressions.html

Attributes

Value members

Concrete methods

inline def add(value: AttributeValue): AttributeValueUpdate
inline def addToSet(string: String): AttributeValueUpdate
inline def addToSet(strings: Set[String]): AttributeValueUpdate
inline def addToSet(num: Int): AttributeValueUpdate
inline def addToSet(num: Long): AttributeValueUpdate
inline def addToSet(num: Double): AttributeValueUpdate
inline def addToSet(num: Float): AttributeValueUpdate
inline def addToSet(num: BigDecimal): AttributeValueUpdate
inline def appendToList(values: AttributeValue*): AttributeValueUpdate
def createTable(tableName: String, partitionKey: String, sortKey: Option[(String, String)], ignoreTableAlreadyExists: Boolean, readCapacityUnits: Int, writeCapacityUnits: Int, indexes: Seq[DynamoDbIndex])(using aws: AwsClient): DescribeTableResponse

The CreateTable operation adds a new table to your account. In an Amazon Web Services account, table names must be unique within each Region. That is, you can have two tables with same name if you create the tables in different Regions.

The CreateTable operation adds a new table to your account. In an Amazon Web Services account, table names must be unique within each Region. That is, you can have two tables with same name if you create the tables in different Regions.

CreateTable is an asynchronous operation. Upon receiving a CreateTable request, DynamoDB immediately returns a response with a TableStatus of CREATING. After the table is created, DynamoDB sets the TableStatus to ACTIVE. You can perform read and write operations only on an ACTIVE table.

You can optionally define secondary indexes on the new table, as part of the CreateTable operation. If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially. Only one table with secondary indexes can be in the CREATING state at any given time.

You can use the DescribeTable action to check the table status.

Attributes

def deleteItemFromTable(tableName: String, key: (String, AttributeValue))(using AwsClient): DeleteItemResponse

Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.

Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.

Attributes

def deleteItemFromTableUsingCompositeKey(tableName: String, keys: Seq[(String, AttributeValue)])(using AwsClient): DeleteItemResponse
def deleteTable(tableName: String)(using aws: AwsClient): Unit

The DeleteTable operation deletes a table and all of its items. After a DeleteTable request, the specified table is in the DELETING state until DynamoDB completes the deletion. If the table is in the ACTIVE state, you can delete it. If a table is in CREATING or UPDATING states, then DynamoDB returns a ResourceInUseException. If the specified table does not exist, DynamoDB returns a ResourceNotFoundException. If table is already in the DELETING state, no error is returned.

The DeleteTable operation deletes a table and all of its items. After a DeleteTable request, the specified table is in the DELETING state until DynamoDB completes the deletion. If the table is in the ACTIVE state, you can delete it. If a table is in CREATING or UPDATING states, then DynamoDB returns a ResourceInUseException. If the specified table does not exist, DynamoDB returns a ResourceNotFoundException. If table is already in the DELETING state, no error is returned.

This operation only applies to Version 2019.11.21 (Current) of global tables.

DynamoDB might continue to accept data read and write operations, such as GetItem and PutItem, on a table in the DELETING state until the table deletion is complete.

When you delete a table, any indexes on that table are also deleted.

If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the DISABLED state, and the stream is automatically deleted after 24 hours.

Use the DescribeTable action to check the status of the table.

Attributes

inline def describeTable(tableName: String)(using aws: AwsClient): TableDescription
inline def describeTimeToLive(tableName: String)(using aws: AwsClient): TimeToLiveDescription
def getItemFromTable(tableName: String, key: (String, AttributeValue))(using AwsClient): Option[DynamoDbItem]

The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data and there will be no Item element in the response.

The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data and there will be no Item element in the response.

GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to true. Although a strongly consistent read might take more time than an eventually consistent read, it always returns the last updated value.

Attributes

def getItemFromTable(tableName: String, key: (String, AttributeValue), projection: Seq[String])(using AwsClient): Option[DynamoDbItem]

The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data and there will be no Item element in the response.

The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data and there will be no Item element in the response.

GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to true. Although a strongly consistent read might take more time than an eventually consistent read, it always returns the last updated value.

Attributes

def getItemFromTableUsingCompositeKey(tableName: String, keys: Seq[(String, AttributeValue)], projection: Seq[String])(using AwsClient): Option[DynamoDbItem]
inline def ifNotExists(value: AttributeValue): AttributeValueUpdate
inline def listOf(value: AttributeValue*): AttributeValue
inline def listTableTags(tableArn: String)(using aws: AwsClient): Seq[(String, String)]
inline def listTables()(using aws: AwsClient): Seq[String]
inline def mapOf(value: DynamoDbItemField*): AttributeValue
transparent inline def maybeExtractValue[V](name: String)[T <: Product](entity: T)(using error: ErrorContext, mirror: ProductOf[T]): Either[error.Error, V]
inline def nullAttributeValue: AttributeValue
inline def prependToList(values: AttributeValue*): AttributeValueUpdate
def putItemInTable(tableName: String, item: DynamoDbItem)(using AwsClient): PutItemResponse

Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item.

Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item.

When you add an item, the primary key attributes are the only required attributes.

Empty String and Binary attribute values are allowed. Attribute values of type String and Binary must have a length greater than zero if the attribute is used as a key attribute for a table or index. Set type attributes cannot be empty.

Invalid Requests with empty values will be rejected with a ValidationException exception.

Attributes

def queryTable(tableName: String, partitionKey: (String, AttributeValue), sortKey: Option[KeyCondition], indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): Seq[DynamoDbItem]

You must provide the name of the partition key attribute and a single value for that attribute. Query returns all items with that partition key value. Optionally, you can provide a sort key attribute and use a comparison operator to refine the search results.

You must provide the name of the partition key attribute and a single value for that attribute. Query returns all items with that partition key value. Optionally, you can provide a sort key attribute and use a comparison operator to refine the search results.

Use the KeyConditionExpression parameter to provide a specific value for the partition key. The Query operation will return all of the items from the table or index with that partition key value. You can optionally narrow the scope of the Query operation by specifying a sort key value and a comparison operator in KeyConditionExpression. To further refine the Query results, you can optionally provide a FilterExpression. A FilterExpression determines which items within the results should be returned to you. All of the other results are discarded.

A Query operation always returns a result set. If no matching items are found, the result set will be empty. Queries that do not return results consume the minimum number of read capacity units for that type of read operation.

Attributes

def queryTableAllPages(tableName: String, partitionKey: (String, AttributeValue), sortKey: Option[KeyCondition], indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int])(using AwsClient): Seq[DynamoDbItem]
def queryTableFullResponse(tableName: String, partitionKey: (String, AttributeValue), sortKey: Option[KeyCondition], indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): QueryResponse
def queryTableWithScrolling(tableName: String, partitionKey: (String, AttributeValue), sortKey: Option[KeyCondition], indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): ItemsWithNextPage
inline def removeFromList(index: Int): AttributeValueUpdate
inline def removeFromSet(string: String): AttributeValueUpdate
inline def removeFromSet[T](set: Set[T]): AttributeValueUpdate
inline def removeFromSet(num: Int): AttributeValueUpdate
inline def removeFromSet(num: Long): AttributeValueUpdate
inline def removeFromSet(num: Double): AttributeValueUpdate
inline def removeFromSet(num: Float): AttributeValueUpdate
inline def removeFromSet(num: BigDecimal): AttributeValueUpdate
def scanTable(tableName: String, indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): Seq[DynamoDbItem]

The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression operation.

The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression operation.

If the total size of scanned items exceeds the maximum dataset size limit of 1 MB, the scan completes and results are returned to the user. The LastEvaluatedKey value is also returned and the requestor can use the LastEvaluatedKey to continue the scan in a subsequent operation. Each scan response also includes number of items that were scanned (ScannedCount) as part of the request. If using a FilterExpression , a scan result can result in no items meeting the criteria and the Count will result in zero. If you did not use a FilterExpression in the scan request, then Count is the same as ScannedCount.

Count and ScannedCount only return the count of items specific to a single scan request and, unless the table is less than 1MB, do not represent the total number of items in the table.

A single Scan operation first reads up to the maximum number of items set (if using the Limit parameter) or a maximum of 1 MB of data and then applies any filtering to the results if a FilterExpression is provided. If LastEvaluatedKey is present in the response, pagination is required to complete the full table scan. For more information, see Paginating the Results in the Amazon DynamoDB Developer Guide.

Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide.

By default, a Scan uses eventually consistent reads when accessing the items in a table. Therefore, the results from an eventually consistent Scan may not include the latest item changes at the time the scan iterates through each item in the table. If you require a strongly consistent read of each item as the scan iterates through the items in the table, you can set the ConsistentRead parameter to true. Strong consistency only relates to the consistency of the read at the item level.

DynamoDB does not provide snapshot isolation for a scan operation when the ConsistentRead parameter is set to true. Thus, a DynamoDB scan operation does not guarantee that all reads in a scan see a consistent snapshot of the table when the scan operation was requested.

Attributes

def scanTableAllPages(tableName: String, indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int])(using AwsClient): Seq[DynamoDbItem]
def scanTableFullResponse(tableName: String, indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): ScanResponse
def scanTableWithScrolling(tableName: String, indexName: Option[String], projection: Option[Seq[String]], filters: Seq[FilterCondition], limit: Option[Int], exclusiveStartKey: Option[DynamoDbItemKey])(using AwsClient): ItemsWithNextPage
inline def setOfNumbers[N : Numeric](value: N*): AttributeValue
inline def setOfStrings(value: String*): AttributeValue
inline def toAttributeValue[T](value: T): AttributeValue
inline def translateProductToDynamoDbItemUpdate[T <: Product](entity: T, removeUndefinedProperties: Boolean)(using mirror: ProductOf[T]): Map[String, AttributeValueUpdate]
def updateItemInTable(tableName: String, key: (String, AttributeValue), update: DynamoDbItemUpdate, returnUpdatedItem: Boolean, onlyIfRecordExists: Boolean)(using AwsClient): UpdateItemResponse

Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values).

Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values).

Attributes

def updateItemInTableUsingCompositeKey(tableName: String, keys: Seq[(String, AttributeValue)], update: DynamoDbItemUpdate, returnUpdatedItem: Boolean, onlyIfRecordExists: Boolean)(using AwsClient): UpdateItemResponse

Concrete fields

val REMOVE: AttributeValue
val convertFromJson: Conversion[Value, AttributeValue]

Givens

Givens

given fromEntity[T : Writer]: fromEntity[T]
given fromInt: fromInt
given fromIterable[T](using x$1: Conversion[T, AttributeValue]): fromIterable[T]
given fromMap[T](using x$1: Conversion[T, AttributeValue]): fromMap[T]
given fromOption[T](using x$1: Conversion[T, AttributeValue]): fromOption[T]
given toValue[T](using x$1: Conversion[T, AttributeValue]): toValue[T]

Extensions

Extensions

extension [A](buffer: Buffer[A])
def putAt(index: Int, value: A, empty: A): Buffer[A]
def removeAt(index: Int): Buffer[A]
extension (condition: Condition)
inline def asExpression(prefix: String, index: Int): String
inline def attributeNameMapping(prefix: String): (String, String)
inline def attributeNameMapping(prefix: String, index: Int): (String, String)
inline def attributeValuesMap(prefix: String): Map[String, AttributeValue]
inline def attributeValuesMap(prefix: String, index: Int): Map[String, AttributeValue]
inline def matches(item: DynamoDbItem): Boolean
inline def matches(extract: String => Option[AttributeValue]): Boolean
inline def show(): String
inline def writeAsExpression(prefix: String): String
extension [T](entity: T)
extension (item: DynamoDbItem)
inline def appendToList(path: String, valueToAdd: AttributeValue): Map[String, AttributeValue]
inline def convertToDynamoJson: Value
inline def convertToJson: Value
inline def debug: Unit
inline def eitherClassOrListMissingKeys[T <: Product](using mirror: ProductOf[T]): Either[List[String], T]
inline def eitherTupleOrListMissingKeys[Types <: Tuple](inline keys: String*): Either[List[String], Types]
inline def filterByPaths(paths: Iterable[String]): DynamoDbItem

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Attributes.html#Expressions.Attributes.NestedElements.DocumentPathExamples

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Attributes.html#Expressions.Attributes.NestedElements.DocumentPathExamples

Attributes

inline def getBoolean(inline key: String, default: Boolean): Boolean
inline def getByPath(path: String): Option[AttributeValue]
inline def getByPath(path: Iterable[String]): Option[AttributeValue]
inline def getDecimal(inline key: String, default: BigDecimal): BigDecimal
inline def getDouble(inline key: String, default: Double): Double
inline def getInt(inline key: String, default: Int): Int
inline def getIntSet(inline key: String, default: Set[Int]): Set[Int]
inline def getList(inline key: String, default: Seq[AttributeValue]): Seq[AttributeValue]
inline def getNestedItem(inline key: String, default: DynamoDbItem): DynamoDbItem
inline def getNestedItemOrError(property: String)(using error: ErrorContext): Either[error.Error, DynamoDbItem]
inline def getOrDefault[T : Reader](inline key: String, default: => T): T
inline def getOrDefault[T : Reader](inline key: String, default: String): T
inline def getOrError[T : Reader](property: String)(using evidence$1: Reader[T], error: ErrorContext): Either[error.Error, T]
inline def getOrFail[T : Reader](inline key: String): T
inline def getString(inline key: String, default: String): String
inline def getStringSet(inline key: String, default: Set[String]): Set[String]
inline def maybe[T](inline key: String): Option[T]
inline def maybe[T : Reader]: Option[T]
inline def maybe[T](pathSeq: Seq[String]): Option[T]
inline def maybeBoolean(inline key: String): Option[Boolean]
inline def maybeClass[T <: Product](using mirror: ProductOf[T]): Option[T]
inline def maybeClass[T <: Product](inline key: String)(using mirror: ProductOf[T]): Option[T]
inline def maybeDecimal(inline key: String): Option[BigDecimal]
inline def maybeDouble(inline key: String): Option[Double]
inline def maybeInt(inline key: String): Option[Int]
inline def maybeIntSet(inline key: String): Option[Set[Int]]
inline def maybeList(inline key: String): Option[Seq[AttributeValue]]
inline def maybeListOf[T : Reader](inline key: String): Option[Seq[T]]
inline def maybeListOfClass[T <: Product](inline key: String)(using mirror: ProductOf[T]): Option[Seq[T]]
inline def maybeNestedItem(inline key: String): Option[DynamoDbItem]
inline def maybeNestedItemOrError(property: String)(using error: ErrorContext): Either[error.Error, Option[DynamoDbItem]]
inline def maybeOrError[T : Reader](property: String)(using evidence$1: Reader[T], error: ErrorContext): Either[error.Error, Option[T]]
inline def maybeString(inline key: String): Option[String]
inline def maybeStringSet(inline key: String): Option[Set[String]]
inline def maybeTuple[Types <: Tuple](inline keys: String*): Option[Types]
inline def prependToList(path: String, valueToAdd: AttributeValue): Map[String, AttributeValue]
inline def prettyPrint: String
inline def removeByPath(path: String): DynamoDbItem
inline def set(inline key: String, value: AttributeValue): DynamoDbItem
inline def setByPath(path: String, value: AttributeValue): DynamoDbItem
inline def setByPath(path: Iterable[String], value: AttributeValue): DynamoDbItem
inline def show: String
extension (item: DynamoDbItemUpdate)
inline def show: String
extension (key: (String, AttributeValue))
inline def show: String
extension (maybeItem: Option[DynamoDbItem])
inline def debug: Unit
inline def maybe[T](key: String): Option[T]
inline def maybe[T](pathSeq: String*): Option[T]
inline def prettyPrint: String
inline def show: String
extension (obj: Obj)
inline def toAttributeValue: AttributeValue
extension (string: String)
extension (thisValue: AttributeValueUpdate)
extension (thisValue: AttributeValue)
def convertToDynamoJson: Value
def convertToJson: Value
inline def getBoolean(default: Boolean): Boolean
def getByIndex(index: Int): Option[AttributeValue]
inline def getByPath(path: String): Option[AttributeValue]
def getByPath(path: Iterable[String]): Option[AttributeValue]
inline def getDecimal(default: => BigDecimal): BigDecimal
inline def getDouble(default: => Double): Double
inline def getDoubleSet(default: => Seq[Double]): Seq[Double]
inline def getInt(default: => Int): Int
inline def getIntSet(default: => Seq[Int]): Seq[Int]
inline def getList(default: => Seq[AttributeValue]): Seq[AttributeValue]
inline def getLong(default: => Long): Long
inline def getNestedItem(default: => DynamoDbItem): DynamoDbItem
inline def getOrDefault[T : Reader](default: => T): T
inline def getOrDefault[T : Reader](default: String): T
inline def getOrDefault[T : Reader](default: Int): T
inline def getString(default: => String): String
inline def getStringList(default: => Seq[String]): Seq[String]
inline def isBlank: Boolean
inline def isBoolean: Boolean
inline def isByteArray: Boolean
inline def isEmpty: Boolean
inline def isList: Boolean
inline def isMap: Boolean
inline def isNull: Boolean
inline def isNumber: Boolean
def isSameAs(otherValue: AttributeValue): Boolean
inline def isSet: Boolean
inline def isSetOfBinary: Boolean
inline def isSetOfNumbers: Boolean
inline def isSetOfStrings: Boolean
inline def isString: Boolean
inline def maybe[T]: Option[T]
inline def maybe[T : Reader](pathSeq: String*): Option[T]
inline def maybeBoolean: Option[Boolean]
inline def maybeClass[T <: Product](using mirror: ProductOf[T]): Option[T]
inline def maybeDouble: Option[Double]
inline def maybeInt: Option[Int]
inline def maybeIntSet: Option[Seq[Int]]
inline def maybeList: Option[Seq[AttributeValue]]
inline def maybeLong: Option[Long]
inline def maybeString: Option[String]
def removeByIndex(index: Int): AttributeValue
def removeByPath(path: Iterable[String]): AttributeValue
def setByIndex(index: Int, value: AttributeValue): AttributeValue
def setByPath(path: Iterable[String], value: AttributeValue): AttributeValue
inline def show: String
inline def unsafeGet[T]: T
extension (updateResponse: UpdateItemResponse)
Generated with