DynamoObject

abstract def canEqual(that: Any): Boolean

abstract def internalToMap: Map[String, DynamoValue]

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def +(x: (String, DynamoValue)): DynamoObject

Operator alias for add

final def -(key: String): DynamoObject

Operator alias for remove

final def <>(that: DynamoObject): DynamoObject

Operator alias for concat

final def ==(arg0: Any): Boolean

final def add(key: String, value: DynamoValue): DynamoObject

Add an entry to the map or overwrites the existing value if there

final def apply(key: String): Option[DynamoValue]

Gets the value mapped to key if it exists

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def concat(that: DynamoObject): DynamoObject

Concatenates two maps

final def contains(key: String): Boolean

Checks if the map contains a certain key

final def eq(arg0: AnyRef): Boolean

final def equals(that: Any): Boolean

def finalize(): Unit

final def get[A](key: String)(implicit arg0: DynamoFormat[A]): Either[DynamoReadError, A]

final def getClass(): Class[_]

final def hashCode(): Int

final def isEmpty: Boolean

Checks if the map is empty

final def isInstanceOf[T0]: Boolean

final def keys: Iterable[String]

Gets the list of keys in the map

final def mapKeys(f: (String) ⇒ String): DynamoObject

Transforms the map by assigning values to new keys

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

Chekcs if the map is not empty

final def notify(): Unit

final def notifyAll(): Unit

final def parTraverse[F[_], M](f: (DynamoValue) ⇒ F[M])(implicit arg0: Parallel[F], arg1: Monoid[M]): F[M]

Traverse the object in parallel fashion and build up monoidal structure

final def parTraverseWith[F[_], M](f: (DynamoValue) ⇒ F[M])(z: M)(c: (M, M) ⇒ M)(implicit arg0: Parallel[F]): F[M]

Traverse the object in parallel foshiono and build up a result out of each value

final def parTraverseWithKey[F[_], M](f: (String, DynamoValue) ⇒ F[M])(z: M)(c: (M, M) ⇒ M)(implicit F: Parallel[F]): F[M]

Traverse the object in parallel fashion and build up a result out of each value and its label

def productIterator: Iterator[Any]

def productPrefix: String

final def remove(key: String): DynamoObject

Remove an entry from the map if there

final def size: Int

Gets the size of the map

final def synchronized[T0](arg0: ⇒ T0): T0

final def toAttributeValue: AttributeValue

Make an AWS SDK value out of this map

final def toDynamoValue: DynamoValue

Make a value out of this map

final def toExpressionAttributeValues: Option[Map[String, AttributeValue]]

Builds a map where the keys are transformed to match the convention for expression attribute values in DynamoDB operations See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeValues.html

final def toJavaMap: Map[String, AttributeValue]

final def toMap[V](implicit D: DynamoFormat[V]): Either[DynamoReadError, Map[String, V]]

Builds a scala.collection.Map if this map is made entirely of values of type V

def toString(): String

final def traverse[M](f: (DynamoValue) ⇒ M)(implicit arg0: Monoid[M]): M

Traverse the object into a monoidal structure

final def traverseWith[M](f: (DynamoValue) ⇒ M)(z: M)(c: (M, M) ⇒ M): M

Traverse the object and build up a result out of each value

final def traverseWithKey[M](f: (String, DynamoValue) ⇒ M)(z: M)(c: (M, M) ⇒ M): M

Traverse the object and build up a result out of each value and its label

final def values: Iterable[DynamoValue]

Gets the list of values in the map

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit