alloy.package.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of smithy4s-core_3 Show documentation
core
There is a newer version: 0.19.0-41-91762fb
package object alloy {

  /** A trait for specifying what example data looks like. Differs from the `smithy.api#examples` trait in that
    * it can be used for any shape, not just operations. Below is an explanation of the different example formats
    * that are supported.
    * 1. SMITHY - this means that the examples will be using the `Document` abstraction and will be specified in
    * a protocol agnostic way
    * 2. JSON - this means the examples will use the `Document` abstraction, but will not be validated by the smithy
    * `NodeValidationVisitor` like the first type are. This type can be used to specify protocol specific examples
    * 3. STRING - this is just a string example and anything can be provided inside of the string.
    * This can be helpful for showing e.g. xml or another encoding that isn't JSON and therefore doesn't fit nicely
    *  with `Node` semantics
    */
  type DataExamples = alloy.DataExamples.Type
  /** Use this trait to give a default value to a structure member. This
    * is not the same as smithy.api#default which is more constrained.
    * You can use `defaultValue` to specify a default that does not align
    * with the target's shape constraints, where as Smithy's `default` trait
    * prevents that. For example:
    * 
    * ```smithy
    * {@literal @}length(min:5)
    * string MyString
    * structure MyStruct {
    *   {@literal @}defaultValue("N/A") // that's valid
    *   s1: MyString
    *   s2: MyString = "N/A" // that's invalid
    * }
    * ```
    */
  type DefaultValue = alloy.DefaultValue.Type
  /** Discriminated unions contain the information about which
    * branch of a union is encoded inside of the object itself.
    * The following union:
    * structure One {
    *   a: Int
    * }
    * structure Two {
    *   b: String
    * }
    * union Test {
    *   one: One
    *   two: Two  
    * }
    * would normally be encoded in JSON as:
    * { "one": { "a": 123 } }
    * when annotated with `{@literal @}discriminated("type")`, it will
    * instead be encoded as:
    * { "a": 123, "type": "one" }
    * This is more efficient than using an untagged encoding,
    * but less efficient than using the default tagged union
    * encoding. Therefore, it should only be used when necessary.
    * Tagged union encodings should be used wherever possible.
    */
  type Discriminated = alloy.Discriminated.Type
  /** A version of {@literal @}examples that is not tied to a validator */
  type UncheckedExamples = alloy.UncheckedExamples.Type
  /** Changes the serialized key of a structure, union, or member. */
  type UrlFormName = alloy.UrlFormName.Type

}