Open enumerations

CHANGELOG.md

@@ -42,6 +42,12 @@ When the smithy4sRenderOptics setting is enabled, Lenses and Prisms will be rend
 
 See https://github.com/disneystreaming/smithy4s/pull/1103
 
+### Open Enumerations
+
+Introduces alternative code generation for enums and intEnums when they are marked with the `alloy#openEnum` trait.
+
+See https://github.com/disneystreaming/smithy4s/pull/1137
+
 # 0.17.14
 
 * Only transform AWS shapes named after standard shapes in [#1127](https://github.com/disneystreaming/smithy4s/pull/1127)

build.sbt

@@ -495,7 +495,10 @@ lazy val decline = (projectMatrix in file("modules/decline"))
       Dependencies.Weaver.cats.value % Test
     )
   )
-  .dependsOn(json)
+  .dependsOn(
+    json,
+    bootstrapped % "test->test"
+  )
   .jvmPlatform(allJvmScalaVersions, jvmDimSettings)
   .jsPlatform(allJsScalaVersions, jsDimSettings)
   .nativePlatform(allNativeScalaVersions, nativeDimSettings)

modules/bootstrapped/src/generated/smithy4s/example/AudioEnum.scala

@@ -31,6 +31,6 @@ object AudioEnum extends Enumeration[AudioEnum] with ShapeTag.Companion[AudioEnu
     GUITAR,
     BASS,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[AudioEnum] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[AudioEnum] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/DummyService.scala

@@ -18,7 +18,7 @@ import smithy4s.schema.Schema.unit
 trait DummyServiceGen[F[_, _, _, _, _]] {
   self =>
 
-  def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, slm: Option[Map[String, String]] = None): F[Queries, Nothing, Unit, Nothing, Nothing]
+  def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, on: Option[OpenNums] = None, ons: Option[OpenNumsStr] = None, slm: Option[Map[String, String]] = None): F[Queries, Nothing, Unit, Nothing, Nothing]
   def dummyPath(str: String, int: Int, ts1: Timestamp, ts2: Timestamp, ts3: Timestamp, ts4: Timestamp, b: Boolean, ie: Numbers): F[PathParams, Nothing, Unit, Nothing, Nothing]
 
   def transform: Transformation.PartiallyApplied[DummyServiceGen[F]] = Transformation.of[DummyServiceGen[F]](this)
@@ -67,19 +67,19 @@ sealed trait DummyServiceOperation[Input, Err, Output, StreamedInput, StreamedOu
 object DummyServiceOperation {
 
   object reified extends DummyServiceGen[DummyServiceOperation] {
-    def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, slm: Option[Map[String, String]] = None) = Dummy(Queries(str, int, ts1, ts2, ts3, ts4, b, sl, ie, slm))
+    def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, on: Option[OpenNums] = None, ons: Option[OpenNumsStr] = None, slm: Option[Map[String, String]] = None) = Dummy(Queries(str, int, ts1, ts2, ts3, ts4, b, sl, ie, on, ons, slm))
     def dummyPath(str: String, int: Int, ts1: Timestamp, ts2: Timestamp, ts3: Timestamp, ts4: Timestamp, b: Boolean, ie: Numbers) = DummyPath(PathParams(str, int, ts1, ts2, ts3, ts4, b, ie))
   }
   class Transformed[P[_, _, _, _, _], P1[_ ,_ ,_ ,_ ,_]](alg: DummyServiceGen[P], f: PolyFunction5[P, P1]) extends DummyServiceGen[P1] {
-    def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, slm: Option[Map[String, String]] = None) = f[Queries, Nothing, Unit, Nothing, Nothing](alg.dummy(str, int, ts1, ts2, ts3, ts4, b, sl, ie, slm))
+    def dummy(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, on: Option[OpenNums] = None, ons: Option[OpenNumsStr] = None, slm: Option[Map[String, String]] = None) = f[Queries, Nothing, Unit, Nothing, Nothing](alg.dummy(str, int, ts1, ts2, ts3, ts4, b, sl, ie, on, ons, slm))
     def dummyPath(str: String, int: Int, ts1: Timestamp, ts2: Timestamp, ts3: Timestamp, ts4: Timestamp, b: Boolean, ie: Numbers) = f[PathParams, Nothing, Unit, Nothing, Nothing](alg.dummyPath(str, int, ts1, ts2, ts3, ts4, b, ie))
   }
 
   def toPolyFunction[P[_, _, _, _, _]](impl: DummyServiceGen[P]): PolyFunction5[DummyServiceOperation, P] = new PolyFunction5[DummyServiceOperation, P] {
     def apply[I, E, O, SI, SO](op: DummyServiceOperation[I, E, O, SI, SO]): P[I, E, O, SI, SO] = op.run(impl) 
   }
   final case class Dummy(input: Queries) extends DummyServiceOperation[Queries, Nothing, Unit, Nothing, Nothing] {
-    def run[F[_, _, _, _, _]](impl: DummyServiceGen[F]): F[Queries, Nothing, Unit, Nothing, Nothing] = impl.dummy(input.str, input.int, input.ts1, input.ts2, input.ts3, input.ts4, input.b, input.sl, input.ie, input.slm)
+    def run[F[_, _, _, _, _]](impl: DummyServiceGen[F]): F[Queries, Nothing, Unit, Nothing, Nothing] = impl.dummy(input.str, input.int, input.ts1, input.ts2, input.ts3, input.ts4, input.b, input.sl, input.ie, input.on, input.ons, input.slm)
     def ordinal = 0
     def endpoint: smithy4s.Endpoint[DummyServiceOperation,Queries, Nothing, Unit, Nothing, Nothing] = Dummy
   }

modules/bootstrapped/src/generated/smithy4s/example/EnumResult.scala

@@ -29,6 +29,6 @@ object EnumResult extends Enumeration[EnumResult] with ShapeTag.Companion[EnumRe
     FIRST,
     SECOND,
   )
-  val tag: EnumTag = EnumTag.IntEnum
+  val tag: EnumTag[EnumResult] = EnumTag.ClosedIntEnum
   implicit val schema: Schema[EnumResult] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/EnumWithDeprecations.scala

@@ -35,6 +35,6 @@ object EnumWithDeprecations extends Enumeration[EnumWithDeprecations] with Shape
     OLD,
     NEW,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[EnumWithDeprecations] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[EnumWithDeprecations] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/EnumWithSymbols.scala

@@ -31,6 +31,6 @@ object EnumWithSymbols extends Enumeration[EnumWithSymbols] with ShapeTag.Compan
     BarBarBar,
     Value2,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[EnumWithSymbols] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[EnumWithSymbols] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/FaceCard.scala

@@ -38,6 +38,6 @@ object FaceCard extends Enumeration[FaceCard] with ShapeTag.Companion[FaceCard]
     ACE,
     JOKER,
   )
-  val tag: EnumTag = EnumTag.IntEnum
+  val tag: EnumTag[FaceCard] = EnumTag.ClosedIntEnum
   implicit val schema: Schema[FaceCard] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/FooEnum.scala

@@ -27,6 +27,6 @@ object FooEnum extends Enumeration[FooEnum] with ShapeTag.Companion[FooEnum] {
   val values: List[FooEnum] = List(
     FOO,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[FooEnum] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[FooEnum] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/HeadersStruct.scala

@@ -11,7 +11,7 @@ import smithy4s.schema.Schema.string
 import smithy4s.schema.Schema.struct
 import smithy4s.schema.Schema.timestamp
 
-final case class HeadersStruct(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, slm: Option[Map[String, String]] = None)
+final case class HeadersStruct(str: Option[String] = None, int: Option[Int] = None, ts1: Option[Timestamp] = None, ts2: Option[Timestamp] = None, ts3: Option[Timestamp] = None, ts4: Option[Timestamp] = None, b: Option[Boolean] = None, sl: Option[List[String]] = None, ie: Option[Numbers] = None, on: Option[OpenNums] = None, ons: Option[OpenNumsStr] = None, slm: Option[Map[String, String]] = None)
 object HeadersStruct extends ShapeTag.Companion[HeadersStruct] {
   val id: ShapeId = ShapeId("smithy4s.example", "HeadersStruct")
 
@@ -27,6 +27,8 @@ object HeadersStruct extends ShapeTag.Companion[HeadersStruct] {
     boolean.optional[HeadersStruct]("b", _.b).addHints(smithy.api.HttpHeader("b")),
     StringList.underlyingSchema.optional[HeadersStruct]("sl", _.sl).addHints(smithy.api.HttpHeader("sl")),
     Numbers.schema.optional[HeadersStruct]("ie", _.ie).addHints(smithy.api.HttpHeader("nums")),
+    OpenNums.schema.optional[HeadersStruct]("on", _.on).addHints(smithy.api.HttpHeader("openNums")),
+    OpenNumsStr.schema.optional[HeadersStruct]("ons", _.ons).addHints(smithy.api.HttpHeader("openNumsStr")),
     StringMap.underlyingSchema.optional[HeadersStruct]("slm", _.slm).addHints(smithy.api.HttpPrefixHeaders("foo-")),
   ){
     HeadersStruct.apply

modules/bootstrapped/src/generated/smithy4s/example/Ingredient.scala

@@ -33,6 +33,6 @@ object Ingredient extends Enumeration[Ingredient] with ShapeTag.Companion[Ingred
     SALAD,
     TOMATO,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[Ingredient] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[Ingredient] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/LeftRight.scala

@@ -29,6 +29,6 @@ object LeftRight extends Enumeration[LeftRight] with ShapeTag.Companion[LeftRigh
     LEFT,
     RIGHT,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[LeftRight] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[LeftRight] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/Letters.scala

@@ -31,6 +31,6 @@ object Letters extends Enumeration[Letters] with ShapeTag.Companion[Letters] {
     B,
     C,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[Letters] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[Letters] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/LowHigh.scala

@@ -36,6 +36,6 @@ object LowHigh extends Enumeration[LowHigh] with ShapeTag.Companion[LowHigh] {
     LOW,
     HIGH,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[LowHigh] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[LowHigh] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/NetworkConnectionType.scala

@@ -32,7 +32,7 @@ object NetworkConnectionType extends Enumeration[NetworkConnectionType] with Sha
     ETHERNET,
     WIFI,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[NetworkConnectionType] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[NetworkConnectionType] = enumeration(tag, values).withId(id).addHints(hints)
 
   implicit val networkConnectionTypeHash: cats.Hash[NetworkConnectionType] = SchemaVisitorHash.fromSchema(schema)

modules/bootstrapped/src/generated/smithy4s/example/Numbers.scala

@@ -29,6 +29,6 @@ object Numbers extends Enumeration[Numbers] with ShapeTag.Companion[Numbers] {
     ONE,
     TWO,
   )
-  val tag: EnumTag = EnumTag.IntEnum
+  val tag: EnumTag[Numbers] = EnumTag.ClosedIntEnum
   implicit val schema: Schema[Numbers] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/OldStyleLeftRight.scala

@@ -29,6 +29,6 @@ object OldStyleLeftRight extends Enumeration[OldStyleLeftRight] with ShapeTag.Co
     LEFT,
     RIGHT,
   )
-  val tag: EnumTag = EnumTag.StringEnum
+  val tag: EnumTag[OldStyleLeftRight] = EnumTag.ClosedStringEnum
   implicit val schema: Schema[OldStyleLeftRight] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/OneTwo.scala

@@ -29,6 +29,6 @@ object OneTwo extends Enumeration[OneTwo] with ShapeTag.Companion[OneTwo] {
     ONE,
     TWO,
   )
-  val tag: EnumTag = EnumTag.IntEnum
+  val tag: EnumTag[OneTwo] = EnumTag.ClosedIntEnum
   implicit val schema: Schema[OneTwo] = enumeration(tag, values).withId(id).addHints(hints)
 }

modules/bootstrapped/src/generated/smithy4s/example/OpenEnumCollisionTest.scala

@@ -0,0 +1,49 @@
+package smithy4s.example
+
+import smithy4s.Enumeration
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.optics.Prism
+import smithy4s.schema.EnumTag
+import smithy4s.schema.Schema.enumeration
+
+sealed abstract class OpenEnumCollisionTest(_value: String, _name: String, _intValue: Int, _hints: Hints) extends Enumeration.Value {
+  override type EnumType = OpenEnumCollisionTest
+  override val value: String = _value
+  override val name: String = _name
+  override val intValue: Int = _intValue
+  override val hints: Hints = _hints
+  override def enumeration: Enumeration[EnumType] = OpenEnumCollisionTest
+  @inline final def widen: OpenEnumCollisionTest = this
+}
+object OpenEnumCollisionTest extends Enumeration[OpenEnumCollisionTest] with ShapeTag.Companion[OpenEnumCollisionTest] {
+  val id: ShapeId = ShapeId("smithy4s.example", "OpenEnumCollisionTest")
+
+  val hints: Hints = Hints(
+    alloy.OpenEnum(),
+  )
+
+  object optics {
+    val ONE: Prism[OpenEnumCollisionTest, OpenEnumCollisionTest.ONE.type] = Prism.partial[OpenEnumCollisionTest, OpenEnumCollisionTest.ONE.type]{ case OpenEnumCollisionTest.ONE => OpenEnumCollisionTest.ONE }(identity)
+    val TWO: Prism[OpenEnumCollisionTest, OpenEnumCollisionTest.TWO.type] = Prism.partial[OpenEnumCollisionTest, OpenEnumCollisionTest.TWO.type]{ case OpenEnumCollisionTest.TWO => OpenEnumCollisionTest.TWO }(identity)
+    val Unknown: Prism[OpenEnumCollisionTest, OpenEnumCollisionTest.Unknown.type] = Prism.partial[OpenEnumCollisionTest, OpenEnumCollisionTest.Unknown.type]{ case OpenEnumCollisionTest.Unknown => OpenEnumCollisionTest.Unknown }(identity)
+    val $unknown: Prism[OpenEnumCollisionTest, OpenEnumCollisionTest.$Unknown] = Prism.partial[OpenEnumCollisionTest, OpenEnumCollisionTest.$Unknown]{ case u: OpenEnumCollisionTest.$Unknown => u }(identity)
+  }
+
+  case object ONE extends OpenEnumCollisionTest("ONE", "ONE", 0, Hints())
+  case object TWO extends OpenEnumCollisionTest("TWO", "TWO", 1, Hints())
+  case object Unknown extends OpenEnumCollisionTest("Unknown", "Unknown", 2, Hints())
+  final case class $Unknown(str: String) extends OpenEnumCollisionTest(str, "$Unknown", -1, Hints.empty)
+
+  val $unknown: String => OpenEnumCollisionTest = $Unknown(_)
+
+  val values: List[OpenEnumCollisionTest] = List(
+    ONE,
+    TWO,
+    Unknown,
+  )
+  val tag: EnumTag[OpenEnumCollisionTest] = EnumTag.OpenStringEnum($unknown)
+  implicit val schema: Schema[OpenEnumCollisionTest] = enumeration(tag, values).withId(id).addHints(hints)
+}

modules/bootstrapped/src/generated/smithy4s/example/OpenEnumCollisionTest2.scala

@@ -0,0 +1,49 @@
+package smithy4s.example
+
+import smithy4s.Enumeration
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.optics.Prism
+import smithy4s.schema.EnumTag
+import smithy4s.schema.Schema.enumeration
+
+sealed abstract class OpenEnumCollisionTest2(_value: String, _name: String, _intValue: Int, _hints: Hints) extends Enumeration.Value {
+  override type EnumType = OpenEnumCollisionTest2
+  override val value: String = _value
+  override val name: String = _name
+  override val intValue: Int = _intValue
+  override val hints: Hints = _hints
+  override def enumeration: Enumeration[EnumType] = OpenEnumCollisionTest2
+  @inline final def widen: OpenEnumCollisionTest2 = this
+}
+object OpenEnumCollisionTest2 extends Enumeration[OpenEnumCollisionTest2] with ShapeTag.Companion[OpenEnumCollisionTest2] {
+  val id: ShapeId = ShapeId("smithy4s.example", "OpenEnumCollisionTest2")
+
+  val hints: Hints = Hints(
+    alloy.OpenEnum(),
+  )
+
+  object optics {
+    val ONE: Prism[OpenEnumCollisionTest2, OpenEnumCollisionTest2.ONE.type] = Prism.partial[OpenEnumCollisionTest2, OpenEnumCollisionTest2.ONE.type]{ case OpenEnumCollisionTest2.ONE => OpenEnumCollisionTest2.ONE }(identity)
+    val TWO: Prism[OpenEnumCollisionTest2, OpenEnumCollisionTest2.TWO.type] = Prism.partial[OpenEnumCollisionTest2, OpenEnumCollisionTest2.TWO.type]{ case OpenEnumCollisionTest2.TWO => OpenEnumCollisionTest2.TWO }(identity)
+    val THREE: Prism[OpenEnumCollisionTest2, OpenEnumCollisionTest2.THREE.type] = Prism.partial[OpenEnumCollisionTest2, OpenEnumCollisionTest2.THREE.type]{ case OpenEnumCollisionTest2.THREE => OpenEnumCollisionTest2.THREE }(identity)
+    val $unknown: Prism[OpenEnumCollisionTest2, OpenEnumCollisionTest2.$Unknown] = Prism.partial[OpenEnumCollisionTest2, OpenEnumCollisionTest2.$Unknown]{ case u: OpenEnumCollisionTest2.$Unknown => u }(identity)
+  }
+
+  case object ONE extends OpenEnumCollisionTest2("ONE", "ONE", 0, Hints())
+  case object TWO extends OpenEnumCollisionTest2("TWO", "TWO", 1, Hints())
+  case object THREE extends OpenEnumCollisionTest2("unknown", "THREE", 2, Hints())
+  final case class $Unknown(str: String) extends OpenEnumCollisionTest2(str, "$Unknown", -1, Hints.empty)
+
+  val $unknown: String => OpenEnumCollisionTest2 = $Unknown(_)
+
+  val values: List[OpenEnumCollisionTest2] = List(
+    ONE,
+    TWO,
+    THREE,
+  )
+  val tag: EnumTag[OpenEnumCollisionTest2] = EnumTag.OpenStringEnum($unknown)
+  implicit val schema: Schema[OpenEnumCollisionTest2] = enumeration(tag, values).withId(id).addHints(hints)
+}

modules/bootstrapped/src/generated/smithy4s/example/OpenEnumCollisionTest3.scala

@@ -0,0 +1,49 @@
+package smithy4s.example
+
+import smithy4s.Enumeration
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.optics.Prism
+import smithy4s.schema.EnumTag
+import smithy4s.schema.Schema.enumeration
+
+sealed abstract class OpenEnumCollisionTest3(_value: String, _name: String, _intValue: Int, _hints: Hints) extends Enumeration.Value {
+  override type EnumType = OpenEnumCollisionTest3
+  override val value: String = _value
+  override val name: String = _name
+  override val intValue: Int = _intValue
+  override val hints: Hints = _hints
+  override def enumeration: Enumeration[EnumType] = OpenEnumCollisionTest3
+  @inline final def widen: OpenEnumCollisionTest3 = this
+}
+object OpenEnumCollisionTest3 extends Enumeration[OpenEnumCollisionTest3] with ShapeTag.Companion[OpenEnumCollisionTest3] {
+  val id: ShapeId = ShapeId("smithy4s.example", "OpenEnumCollisionTest3")
+
+  val hints: Hints = Hints(
+    alloy.OpenEnum(),
+  )
+
+  object optics {
+    val ONE: Prism[OpenEnumCollisionTest3, OpenEnumCollisionTest3.ONE.type] = Prism.partial[OpenEnumCollisionTest3, OpenEnumCollisionTest3.ONE.type]{ case OpenEnumCollisionTest3.ONE => OpenEnumCollisionTest3.ONE }(identity)
+    val TWO: Prism[OpenEnumCollisionTest3, OpenEnumCollisionTest3.TWO.type] = Prism.partial[OpenEnumCollisionTest3, OpenEnumCollisionTest3.TWO.type]{ case OpenEnumCollisionTest3.TWO => OpenEnumCollisionTest3.TWO }(identity)
+    val unknown: Prism[OpenEnumCollisionTest3, OpenEnumCollisionTest3.unknown.type] = Prism.partial[OpenEnumCollisionTest3, OpenEnumCollisionTest3.unknown.type]{ case OpenEnumCollisionTest3.unknown => OpenEnumCollisionTest3.unknown }(identity)
+    val $unknown: Prism[OpenEnumCollisionTest3, OpenEnumCollisionTest3.$Unknown] = Prism.partial[OpenEnumCollisionTest3, OpenEnumCollisionTest3.$Unknown]{ case u: OpenEnumCollisionTest3.$Unknown => u }(identity)
+  }
+
+  case object ONE extends OpenEnumCollisionTest3("ONE", "ONE", 0, Hints())
+  case object TWO extends OpenEnumCollisionTest3("TWO", "TWO", 1, Hints())
+  case object unknown extends OpenEnumCollisionTest3("unknown", "unknown", 2, Hints())
+  final case class $Unknown(str: String) extends OpenEnumCollisionTest3(str, "$Unknown", -1, Hints.empty)
+
+  val $unknown: String => OpenEnumCollisionTest3 = $Unknown(_)
+
+  val values: List[OpenEnumCollisionTest3] = List(
+    ONE,
+    TWO,
+    unknown,
+  )
+  val tag: EnumTag[OpenEnumCollisionTest3] = EnumTag.OpenStringEnum($unknown)
+  implicit val schema: Schema[OpenEnumCollisionTest3] = enumeration(tag, values).withId(id).addHints(hints)
+}