Define an operation to support multiple types of inputs?

[salong206]

How can I write a operation that supports an endpoint whose input can be one of a set of inputs?
Through the use of oneOf, endpoints can validate the input based on the object type. However, operations in Smithy take in a single input shape.
In my use case, the inputs common fields with some unique fields distinguishing them.

Sample OpenAPI spec of an endpoint that supports multiple input types

paths:
  /dataType:
    patch:
      requestBody:
        content:
          application/json:
            schema:
              oneOf:
                - $ref: "#/components/schemas/StringType"
                - $ref: "#/components/schemas/IntegerType"
      responses:
        "200":
          description: Updated

components:
  schemas:
    StringType:
      type: object
      properties:
        key:
          type: string
        value:
          type: string
        description:
          type: string
        length:
          type: integer
    IntegerType:
      type: object
      properties:
        key:
          type: string
        value:
          type: integer
        description:
          type: string

The similarity between inputs makes it seem like a good candidate for mixins. However, mixins are not meant to be used for polymorphism and operations with mixins may not define input shape
The union data structure seemed like it could work at first. However, Smithy implements unions as tagged unions, meaning each member must have a unique tag/key. This extra tag/key results in extra nesting when serializing JSON.

These restrictions make it seem like I'd need to define the same operation multiple times for each supported input. So rather than having:

operation CreateDataType {
   input: CreateDataTypeInput
   ...
}

structure CreateDataTypeInput {
   // Something that supports both the String and Integer type
}

I need to define

operation CreateStringDataType {
   input: CreateStringDataTypeInput
   ...
}

structure CreateStringDataTypeInput {
  key: String,
  value: String,
  description: String
  length: Integer
}

operation CreateIntegerDataType {
   input: CreateIntegerDataTypeInput
   ...
}

structure CreateIntegerDataTypeInput {
  key: String,
  value: Integer,
  description: String
}

Please advise the best way to implement this and correct me if I misunderstood anything. Thanks