diff --git a/modules/redis/src/main/scala/zio/redis/Input.scala b/modules/redis/src/main/scala/zio/redis/Input.scala
index d784094dc..44a42277c 100644
--- a/modules/redis/src/main/scala/zio/redis/Input.scala
+++ b/modules/redis/src/main/scala/zio/redis/Input.scala
@@ -17,18 +17,18 @@
 package zio.redis
 
 import zio._
-import zio.redis.internal.{RespCommand, RespCommandArgument}
+import zio.redis.internal.{RespCommandArguments, RespCommandArgument}
 import zio.schema.codec.BinaryCodec
 
 import java.time.Instant
 import java.util.concurrent.TimeUnit
 
 sealed trait Input[-A] { self =>
-  private[redis] def encode(data: A): RespCommand
+  private[redis] def encode(data: A): RespCommandArguments
 
   final def contramap[B](f: B => A): Input[B] =
     new Input[B] {
-      def encode(data: B): RespCommand = self.encode(f(data))
+      def encode(data: B): RespCommandArguments = self.encode(f(data))
     }
 }
 
@@ -36,46 +36,46 @@ object Input {
   def apply[A](implicit input: Input[A]): Input[A] = input
 
   case object AbsTtlInput extends Input[AbsTtl] {
-    def encode(data: AbsTtl): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: AbsTtl): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object AddressInput extends Input[Address] {
-    def encode(data: Address): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.asString))
+    def encode(data: Address): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.asString))
   }
 
   case object AggregateInput extends Input[Aggregate] {
-    def encode(data: Aggregate): RespCommand =
-      RespCommand(RespCommandArgument.Literal("AGGREGATE"), RespCommandArgument.Literal(data.asString))
+    def encode(data: Aggregate): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("AGGREGATE"), RespCommandArgument.Literal(data.asString))
   }
 
   case object AlphaInput extends Input[Alpha] {
-    def encode(data: Alpha): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Alpha): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   final case class ArbitraryKeyInput[A: BinaryCodec]() extends Input[A] {
-    def encode(data: A): RespCommand =
-      RespCommand(RespCommandArgument.Key(data))
+    def encode(data: A): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Key(data))
   }
 
   final case class ArbitraryValueInput[A: BinaryCodec]() extends Input[A] {
-    def encode(data: A): RespCommand =
-      RespCommand(RespCommandArgument.Value(data))
+    def encode(data: A): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data))
   }
 
   case object AuthInput extends Input[Auth] {
-    def encode(data: Auth): RespCommand =
+    def encode(data: Auth): RespCommandArguments =
       data.username match {
         case Some(username) =>
-          RespCommand(RespCommandArgument.Value(username), RespCommandArgument.Value(data.password))
-        case None => RespCommand(RespCommandArgument.Value(data.password))
+          RespCommandArguments(RespCommandArgument.Value(username), RespCommandArgument.Value(data.password))
+        case None => RespCommandArguments(RespCommandArgument.Value(data.password))
       }
   }
 
   case object BitFieldCommandInput extends Input[BitFieldCommand] {
-    def encode(data: BitFieldCommand): RespCommand = {
+    def encode(data: BitFieldCommand): RespCommandArguments = {
       import BitFieldCommand._
 
       val respArgs = data match {
@@ -102,163 +102,158 @@ object Input {
         case bfo: BitFieldOverflow =>
           Chunk(RespCommandArgument.Literal("OVERFLOW"), RespCommandArgument.Literal(bfo.asString))
       }
-      RespCommand(respArgs)
+      RespCommandArguments(respArgs)
     }
   }
 
   case object BitOperationInput extends Input[BitOperation] {
-    def encode(data: BitOperation): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: BitOperation): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object BitPosRangeInput extends Input[BitPosRange] {
-    def encode(data: BitPosRange): RespCommand = {
+    def encode(data: BitPosRange): RespCommandArguments = {
       val start    = RespCommandArgument.Value(data.start.toString)
       val respArgs = data.end.fold(Chunk.single(start))(end => Chunk(start, RespCommandArgument.Value(end.toString)))
-      RespCommand(respArgs)
+      RespCommandArguments(respArgs)
     }
   }
 
   case object BlockInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand =
-      RespCommand(RespCommandArgument.Literal("BLOCK"), RespCommandArgument.Value(data.toMillis.toString))
+    def encode(data: Duration): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("BLOCK"), RespCommandArgument.Value(data.toMillis.toString))
   }
 
   case object BoolInput extends Input[Boolean] {
-    def encode(data: Boolean): RespCommand =
-      RespCommand(RespCommandArgument.Literal(if (data) "1" else "0"))
+    def encode(data: Boolean): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(if (data) "1" else "0"))
   }
 
   case object ByInput extends Input[String] {
-    def encode(data: String): RespCommand =
-      RespCommand(RespCommandArgument.Literal("BY"), RespCommandArgument.Value(data))
+    def encode(data: String): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("BY"), RespCommandArgument.Value(data))
   }
 
   case object ChangedInput extends Input[Changed] {
-    def encode(data: Changed): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
-  }
-
-  case object CommandNameInput extends Input[String] {
-    def encode(data: String): RespCommand =
-      RespCommand(RespCommandArgument.CommandName(data))
+    def encode(data: Changed): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object CopyInput extends Input[Copy] {
-    def encode(data: Copy): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Copy): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object CountInput extends Input[Count] {
-    def encode(data: Count): RespCommand =
-      RespCommand(RespCommandArgument.Literal("COUNT"), RespCommandArgument.Value(data.count.toString))
+    def encode(data: Count): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("COUNT"), RespCommandArgument.Value(data.count.toString))
   }
 
   case object DoubleInput extends Input[Double] {
-    def encode(data: Double): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.toString))
+    def encode(data: Double): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.toString))
   }
 
   case object DurationMillisecondsInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.toMillis.toString))
+    def encode(data: Duration): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.toMillis.toString))
   }
 
   case object DurationSecondsInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand = {
+    def encode(data: Duration): RespCommandArguments = {
       val seconds = TimeUnit.MILLISECONDS.toSeconds(data.toMillis)
-      RespCommand(RespCommandArgument.Value(seconds.toString))
+      RespCommandArguments(RespCommandArgument.Value(seconds.toString))
     }
   }
 
   case object DurationTtlInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand = {
+    def encode(data: Duration): RespCommandArguments = {
       val milliseconds = data.toMillis
-      RespCommand(RespCommandArgument.Literal("PX"), RespCommandArgument.Value(milliseconds.toString))
+      RespCommandArguments(RespCommandArgument.Literal("PX"), RespCommandArgument.Value(milliseconds.toString))
     }
   }
 
   final case class EvalInput[-K, -V](inputK: Input[K], inputV: Input[V]) extends Input[(String, Chunk[K], Chunk[V])] {
-    def encode(data: (String, Chunk[K], Chunk[V])): RespCommand = {
+    def encode(data: (String, Chunk[K], Chunk[V])): RespCommandArguments = {
       val (lua, keys, args) = data
-      val encodedScript     = RespCommand(RespCommandArgument.Value(lua), RespCommandArgument.Value(keys.size.toString))
-      val encodedKeys = keys.foldLeft(RespCommand.empty)((acc, a) =>
-        acc ++ inputK.encode(a).mapArguments(arg => RespCommandArgument.Key(arg.value.value))
+      val encodedScript     = RespCommandArguments(RespCommandArgument.Value(lua), RespCommandArgument.Value(keys.size.toString))
+      val encodedKeys = keys.foldLeft(RespCommandArguments.empty)((acc, a) =>
+        acc ++ inputK.encode(a).map(arg => RespCommandArgument.Key(arg.value.value))
       )
-      val encodedArgs = args.foldLeft(RespCommand.empty)((acc, a) =>
-        acc ++ inputV.encode(a).mapArguments(arg => RespCommandArgument.Value(arg.value.value))
+      val encodedArgs = args.foldLeft(RespCommandArguments.empty)((acc, a) =>
+        acc ++ inputV.encode(a).map(arg => RespCommandArgument.Value(arg.value.value))
       )
       encodedScript ++ encodedKeys ++ encodedArgs
     }
   }
 
   case object FreqInput extends Input[Freq] {
-    def encode(data: Freq): RespCommand =
-      RespCommand(RespCommandArgument.Literal("FREQ"), RespCommandArgument.Value(data.frequency))
+    def encode(data: Freq): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("FREQ"), RespCommandArgument.Value(data.frequency))
   }
 
   case object GetInput extends Input[String] {
-    def encode(data: String): RespCommand =
-      RespCommand(RespCommandArgument.Literal("GET"), RespCommandArgument.Value(data))
+    def encode(data: String): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("GET"), RespCommandArgument.Value(data))
   }
 
   final case class GetExInput[K: BinaryCodec]() extends Input[(K, Expire, Duration)] {
-    def encode(data: (K, Expire, Duration)): RespCommand =
+    def encode(data: (K, Expire, Duration)): RespCommandArguments =
       data match {
         case (key, Expire.SetExpireSeconds, duration) =>
-          RespCommand(RespCommandArgument.Key(key), RespCommandArgument.Literal("EX")) ++ DurationSecondsInput.encode(
+          RespCommandArguments(RespCommandArgument.Key(key), RespCommandArgument.Literal("EX")) ++ DurationSecondsInput.encode(
             duration
           )
         case (key, Expire.SetExpireMilliseconds, duration) =>
-          RespCommand(RespCommandArgument.Key(key), RespCommandArgument.Literal("PX")) ++ DurationMillisecondsInput
+          RespCommandArguments(RespCommandArgument.Key(key), RespCommandArgument.Literal("PX")) ++ DurationMillisecondsInput
             .encode(duration)
       }
   }
 
   final case class GetExAtInput[K: BinaryCodec]() extends Input[(K, ExpiredAt, Instant)] {
-    def encode(data: (K, ExpiredAt, Instant)): RespCommand =
+    def encode(data: (K, ExpiredAt, Instant)): RespCommandArguments =
       data match {
         case (key, ExpiredAt.SetExpireAtSeconds, instant) =>
-          RespCommand(RespCommandArgument.Key(key), RespCommandArgument.Literal("EXAT")) ++ TimeSecondsInput.encode(
+          RespCommandArguments(RespCommandArgument.Key(key), RespCommandArgument.Literal("EXAT")) ++ TimeSecondsInput.encode(
             instant
           )
         case (key, ExpiredAt.SetExpireAtMilliseconds, instant) =>
-          RespCommand(RespCommandArgument.Key(key), RespCommandArgument.Literal("PXAT")) ++ TimeMillisecondsInput
+          RespCommandArguments(RespCommandArgument.Key(key), RespCommandArgument.Literal("PXAT")) ++ TimeMillisecondsInput
             .encode(instant)
       }
   }
 
   final case class GetExPersistInput[K: BinaryCodec]() extends Input[(K, Boolean)] {
-    def encode(data: (K, Boolean)): RespCommand =
-      RespCommand(
+    def encode(data: (K, Boolean)): RespCommandArguments =
+      RespCommandArguments(
         if (data._2) Chunk(RespCommandArgument.Key(data._1), RespCommandArgument.Literal("PERSIST"))
         else Chunk(RespCommandArgument.Key(data._1))
       )
   }
 
   case object GetKeywordInput extends Input[GetKeyword] {
-    def encode(data: GetKeyword): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: GetKeyword): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object IdleInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand =
-      RespCommand(RespCommandArgument.Literal("IDLE"), RespCommandArgument.Value(data.toMillis.toString))
+    def encode(data: Duration): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("IDLE"), RespCommandArgument.Value(data.toMillis.toString))
   }
 
   case object IdleTimeInput extends Input[IdleTime] {
-    def encode(data: IdleTime): RespCommand =
-      RespCommand(RespCommandArgument.Literal("IDLETIME"), RespCommandArgument.Value(data.seconds.toString))
+    def encode(data: IdleTime): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("IDLETIME"), RespCommandArgument.Value(data.seconds.toString))
   }
 
   case object IdInput extends Input[Long] {
-    def encode(data: Long): RespCommand =
-      RespCommand(RespCommandArgument.Literal("ID"), RespCommandArgument.Value(data.toString))
+    def encode(data: Long): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("ID"), RespCommandArgument.Value(data.toString))
   }
 
   case object IdsInput extends Input[(Long, List[Long])] {
-    def encode(data: (Long, List[Long])): RespCommand =
-      RespCommand(
+    def encode(data: (Long, List[Long])): RespCommandArguments =
+      RespCommandArguments(
         Chunk.fromIterable(
           RespCommandArgument.Literal("ID") +: (data._1 :: data._2).map(id => RespCommandArgument.Value(id.toString))
         )
@@ -266,23 +261,23 @@ object Input {
   }
 
   case object IncrementInput extends Input[Increment] {
-    def encode(data: Increment): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Increment): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object IntInput extends Input[Int] {
-    def encode(data: Int): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.toString))
+    def encode(data: Int): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.toString))
   }
 
   case object KeepTtlInput extends Input[KeepTtl] {
-    def encode(data: KeepTtl): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: KeepTtl): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object LcsQueryTypeInput extends Input[LcsQueryType] {
-    def encode(data: LcsQueryType): RespCommand = data match {
-      case LcsQueryType.Len => RespCommand(RespCommandArgument.Literal("LEN"))
+    def encode(data: LcsQueryType): RespCommandArguments = data match {
+      case LcsQueryType.Len => RespCommandArguments(RespCommandArgument.Literal("LEN"))
       case LcsQueryType.Idx(minMatchLength, withMatchLength) =>
         val idx = Chunk.single(RespCommandArgument.Literal("IDX"))
         val min =
@@ -292,13 +287,13 @@ object Input {
         val length =
           if (withMatchLength) Chunk.single(RespCommandArgument.Literal("WITHMATCHLEN"))
           else Chunk.empty[RespCommandArgument]
-        RespCommand(Chunk(idx, min, length).flatten)
+        RespCommandArguments(Chunk(idx, min, length).flatten)
     }
   }
 
   case object LimitInput extends Input[Limit] {
-    def encode(data: Limit): RespCommand =
-      RespCommand(
+    def encode(data: Limit): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Literal("LIMIT"),
         RespCommandArgument.Value(data.offset.toString),
         RespCommandArgument.Value(data.count.toString)
@@ -306,176 +301,176 @@ object Input {
   }
 
   case object ListMaxLenInput extends Input[ListMaxLen] {
-    def encode(data: ListMaxLen): RespCommand =
-      RespCommand(RespCommandArgument.Literal("MAXLEN"), RespCommandArgument.Value(data.count.toString))
+    def encode(data: ListMaxLen): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("MAXLEN"), RespCommandArgument.Value(data.count.toString))
   }
 
   case object LongInput extends Input[Long] {
-    def encode(data: Long): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.toString))
+    def encode(data: Long): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.toString))
   }
 
   case object LongLatInput extends Input[LongLat] {
-    def encode(data: LongLat): RespCommand =
-      RespCommand(
+    def encode(data: LongLat): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Value(data.longitude.toString),
         RespCommandArgument.Value(data.latitude.toString)
       )
   }
 
   final case class MemberScoreInput[M: BinaryCodec]() extends Input[MemberScore[M]] {
-    def encode(data: MemberScore[M]): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.score.toString), RespCommandArgument.Value(data.member))
+    def encode(data: MemberScore[M]): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.score.toString), RespCommandArgument.Value(data.member))
   }
 
   case object NoAckInput extends Input[NoAck] {
-    def encode(data: NoAck): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.asString))
+    def encode(data: NoAck): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.asString))
   }
 
   case object NoInput extends Input[Unit] {
-    def encode(data: Unit): RespCommand = RespCommand.empty
+    def encode(data: Unit): RespCommandArguments = RespCommandArguments.empty
   }
 
   final case class NonEmptyList[-A](input: Input[A]) extends Input[(A, List[A])] {
-    def encode(data: (A, List[A])): RespCommand =
-      (data._1 :: data._2).foldLeft(RespCommand.empty)((acc, a) => acc ++ input.encode(a))
+    def encode(data: (A, List[A])): RespCommandArguments =
+      (data._1 :: data._2).foldLeft(RespCommandArguments.empty)((acc, a) => acc ++ input.encode(a))
   }
 
   final case class OptionalInput[-A](a: Input[A]) extends Input[Option[A]] {
-    def encode(data: Option[A]): RespCommand =
-      data.fold(RespCommand.empty)(a.encode)
+    def encode(data: Option[A]): RespCommandArguments =
+      data.fold(RespCommandArguments.empty)(a.encode)
   }
 
   case object OrderInput extends Input[Order] {
-    def encode(data: Order): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.asString))
+    def encode(data: Order): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.asString))
   }
 
   case object PatternInput extends Input[Pattern] {
-    def encode(data: Pattern): RespCommand =
-      RespCommand(RespCommandArgument.Literal("MATCH"), RespCommandArgument.Value(data.pattern))
+    def encode(data: Pattern): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("MATCH"), RespCommandArgument.Value(data.pattern))
   }
 
   case object PositionInput extends Input[Position] {
-    def encode(data: Position): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Position): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object RadiusUnitInput extends Input[RadiusUnit] {
-    def encode(data: RadiusUnit): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.asString))
+    def encode(data: RadiusUnit): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.asString))
   }
 
   case object RangeInput extends Input[Range] {
-    def encode(data: Range): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.start.toString), RespCommandArgument.Value(data.end.toString))
+    def encode(data: Range): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.start.toString), RespCommandArgument.Value(data.end.toString))
   }
 
   case object RankInput extends Input[Rank] {
-    def encode(data: Rank): RespCommand =
-      RespCommand(RespCommandArgument.Literal("RANK"), RespCommandArgument.Value(data.rank.toString))
+    def encode(data: Rank): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("RANK"), RespCommandArgument.Value(data.rank.toString))
   }
 
   case object RedisTypeInput extends Input[RedisType] {
-    def encode(data: RedisType): RespCommand =
-      RespCommand(RespCommandArgument.Literal("TYPE"), RespCommandArgument.Literal(data.asString))
+    def encode(data: RedisType): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("TYPE"), RespCommandArgument.Literal(data.asString))
   }
 
   case object ReplaceInput extends Input[Replace] {
-    def encode(data: Replace): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Replace): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object RetryCountInput extends Input[Long] {
-    def encode(data: Long): RespCommand =
-      RespCommand(RespCommandArgument.Literal("RETRYCOUNT"), RespCommandArgument.Value(data.toString))
+    def encode(data: Long): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("RETRYCOUNT"), RespCommandArgument.Value(data.toString))
   }
 
   case object ScriptDebugInput extends Input[DebugMode] {
-    def encode(data: DebugMode): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: DebugMode): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object ScriptFlushInput extends Input[FlushMode] {
-    def encode(data: FlushMode): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: FlushMode): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object SideInput extends Input[Side] {
-    def encode(data: Side): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: Side): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object StoreDistInput extends Input[StoreDist] {
-    def encode(data: StoreDist): RespCommand =
-      RespCommand(RespCommandArgument.Literal("STOREDIST"), RespCommandArgument.Value(data.key))
+    def encode(data: StoreDist): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("STOREDIST"), RespCommandArgument.Value(data.key))
   }
 
   case object StoreInput extends Input[Store] {
-    def encode(data: Store): RespCommand =
-      RespCommand(RespCommandArgument.Literal("STORE"), RespCommandArgument.Value(data.key))
+    def encode(data: Store): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("STORE"), RespCommandArgument.Value(data.key))
   }
 
   case object StreamMaxLenInput extends Input[StreamMaxLen] {
-    def encode(data: StreamMaxLen): RespCommand = {
+    def encode(data: StreamMaxLen): RespCommandArguments = {
       val chunk =
         if (data.approximate) Chunk(RespCommandArgument.Literal("MAXLEN"), RespCommandArgument.Literal("~"))
         else Chunk.single(RespCommandArgument.Literal("MAXLEN"))
 
-      RespCommand(chunk :+ RespCommandArgument.Value(data.count.toString))
+      RespCommandArguments(chunk :+ RespCommandArgument.Value(data.count.toString))
     }
   }
 
   final case class StreamsInput[K: BinaryCodec, V: BinaryCodec]() extends Input[((K, V), Chunk[(K, V)])] {
-    def encode(data: ((K, V), Chunk[(K, V)])): RespCommand = {
+    def encode(data: ((K, V), Chunk[(K, V)])): RespCommandArguments = {
       val (keys, ids) = (data._1 +: data._2).map { case (key, value) =>
         (RespCommandArgument.Key(key), RespCommandArgument.Value(value))
       }.unzip
 
-      RespCommand(Chunk.single(RespCommandArgument.Literal("STREAMS")) ++ keys ++ ids)
+      RespCommandArguments(Chunk.single(RespCommandArgument.Literal("STREAMS")) ++ keys ++ ids)
     }
   }
 
   case object StringInput extends Input[String] {
-    def encode(data: String): RespCommand =
-      RespCommand(RespCommandArgument.Value(data))
+    def encode(data: String): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data))
   }
 
   case object TimeInput extends Input[Duration] {
-    def encode(data: Duration): RespCommand =
-      RespCommand(RespCommandArgument.Literal("TIME"), RespCommandArgument.Value(data.toMillis.toString))
+    def encode(data: Duration): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal("TIME"), RespCommandArgument.Value(data.toMillis.toString))
   }
 
   case object TimeMillisecondsInput extends Input[Instant] {
-    def encode(data: Instant): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.toEpochMilli.toString))
+    def encode(data: Instant): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.toEpochMilli.toString))
   }
 
   case object TimeSecondsInput extends Input[Instant] {
-    def encode(data: Instant): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.getEpochSecond.toString))
+    def encode(data: Instant): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.getEpochSecond.toString))
   }
 
   final case class Tuple2[-A, -B](_1: Input[A], _2: Input[B]) extends Input[(A, B)] {
-    def encode(data: (A, B)): RespCommand =
+    def encode(data: (A, B)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2)
   }
 
   final case class Tuple3[-A, -B, -C](_1: Input[A], _2: Input[B], _3: Input[C]) extends Input[(A, B, C)] {
-    def encode(data: (A, B, C)): RespCommand =
+    def encode(data: (A, B, C)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3)
   }
 
   final case class Tuple4[-A, -B, -C, -D](_1: Input[A], _2: Input[B], _3: Input[C], _4: Input[D])
       extends Input[(A, B, C, D)] {
-    def encode(data: (A, B, C, D)): RespCommand =
+    def encode(data: (A, B, C, D)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4)
   }
 
   final case class Tuple5[-A, -B, -C, -D, -E](_1: Input[A], _2: Input[B], _3: Input[C], _4: Input[D], _5: Input[E])
       extends Input[(A, B, C, D, E)] {
-    def encode(data: (A, B, C, D, E)): RespCommand =
+    def encode(data: (A, B, C, D, E)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++ _5.encode(data._5)
   }
 
@@ -487,7 +482,7 @@ object Input {
     _5: Input[E],
     _6: Input[F]
   ) extends Input[(A, B, C, D, E, F)] {
-    def encode(data: (A, B, C, D, E, F)): RespCommand =
+    def encode(data: (A, B, C, D, E, F)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++ _5.encode(data._5) ++
         _6.encode(data._6)
   }
@@ -501,7 +496,7 @@ object Input {
     _6: Input[F],
     _7: Input[G]
   ) extends Input[(A, B, C, D, E, F, G)] {
-    def encode(data: (A, B, C, D, E, F, G)): RespCommand =
+    def encode(data: (A, B, C, D, E, F, G)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++ _5.encode(data._5) ++
         _6.encode(data._6) ++ _7.encode(data._7)
   }
@@ -517,7 +512,7 @@ object Input {
     _8: Input[H],
     _9: Input[I]
   ) extends Input[(A, B, C, D, E, F, G, H, I)] {
-    def encode(data: (A, B, C, D, E, F, G, H, I)): RespCommand =
+    def encode(data: (A, B, C, D, E, F, G, H, I)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++ _5.encode(data._5) ++
         _6.encode(data._6) ++ _7.encode(data._7) ++ _8.encode(data._8) ++ _9.encode(data._9)
   }
@@ -534,7 +529,7 @@ object Input {
     _9: Input[I],
     _10: Input[J]
   ) extends Input[(A, B, C, D, E, F, G, H, I, J)] {
-    def encode(data: (A, B, C, D, E, F, G, H, I, J)): RespCommand =
+    def encode(data: (A, B, C, D, E, F, G, H, I, J)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++
         _5.encode(data._5) ++ _6.encode(data._6) ++ _7.encode(data._7) ++ _8.encode(data._8) ++
         _9.encode(data._9) ++ _10.encode(data._10)
@@ -553,75 +548,75 @@ object Input {
     _10: Input[J],
     _11: Input[K]
   ) extends Input[(A, B, C, D, E, F, G, H, I, J, K)] {
-    def encode(data: (A, B, C, D, E, F, G, H, I, J, K)): RespCommand =
+    def encode(data: (A, B, C, D, E, F, G, H, I, J, K)): RespCommandArguments =
       _1.encode(data._1) ++ _2.encode(data._2) ++ _3.encode(data._3) ++ _4.encode(data._4) ++
         _5.encode(data._5) ++ _6.encode(data._6) ++ _7.encode(data._7) ++ _8.encode(data._8) ++
         _9.encode(data._9) ++ _10.encode(data._10) ++ _11.encode(data._11)
   }
 
   case object UpdateInput extends Input[Update] {
-    def encode(data: Update): RespCommand =
-      RespCommand(RespCommandArgument.Value(data.asString))
+    def encode(data: Update): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data.asString))
   }
 
   case object ValueInput extends Input[Chunk[Byte]] {
-    def encode(data: Chunk[Byte]): RespCommand =
-      RespCommand(RespCommandArgument.Value(data))
+    def encode(data: Chunk[Byte]): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Value(data))
   }
 
   final case class Varargs[-A](input: Input[A]) extends Input[Iterable[A]] {
-    def encode(data: Iterable[A]): RespCommand =
-      data.foldLeft(RespCommand.empty)((acc, a) => acc ++ input.encode(a))
+    def encode(data: Iterable[A]): RespCommandArguments =
+      data.foldLeft(RespCommandArguments.empty)((acc, a) => acc ++ input.encode(a))
   }
 
   case object WeightsInput extends Input[::[Double]] {
-    def encode(data: ::[Double]): RespCommand = {
+    def encode(data: ::[Double]): RespCommandArguments = {
       val args = data.foldLeft(Chunk.single[RespCommandArgument](RespCommandArgument.Literal("WEIGHTS"))) { (acc, a) =>
         acc ++ Chunk.single(RespCommandArgument.Value(a.toString))
       }
-      RespCommand(args)
+      RespCommandArguments(args)
     }
   }
 
   case object WithCoordInput extends Input[WithCoord] {
-    def encode(data: WithCoord): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithCoord): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithDistInput extends Input[WithDist] {
-    def encode(data: WithDist): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithDist): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithForceInput extends Input[WithForce] {
-    def encode(data: WithForce): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithForce): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithHashInput extends Input[WithHash] {
-    def encode(data: WithHash): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithHash): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithJustIdInput extends Input[WithJustId] {
-    def encode(data: WithJustId): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithJustId): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithScoreInput extends Input[WithScore] {
-    def encode(data: WithScore): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithScore): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   case object WithScoresInput extends Input[WithScores] {
-    def encode(data: WithScores): RespCommand =
-      RespCommand(RespCommandArgument.Literal(data.asString))
+    def encode(data: WithScores): RespCommandArguments =
+      RespCommandArguments(RespCommandArgument.Literal(data.asString))
   }
 
   final case class XGroupCreateConsumerInput[K: BinaryCodec, G: BinaryCodec, C: BinaryCodec]()
       extends Input[XGroupCommand.CreateConsumer[K, G, C]] {
-    def encode(data: XGroupCommand.CreateConsumer[K, G, C]): RespCommand =
-      RespCommand(
+    def encode(data: XGroupCommand.CreateConsumer[K, G, C]): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Literal("CREATECONSUMER"),
         RespCommandArgument.Key(data.key),
         RespCommandArgument.Value(data.group),
@@ -631,7 +626,7 @@ object Input {
 
   final case class XGroupCreateInput[K: BinaryCodec, G: BinaryCodec, I: BinaryCodec]()
       extends Input[XGroupCommand.Create[K, G, I]] {
-    def encode(data: XGroupCommand.Create[K, G, I]): RespCommand = {
+    def encode(data: XGroupCommand.Create[K, G, I]): RespCommandArguments = {
       val chunk = Chunk(
         RespCommandArgument.Literal("CREATE"),
         RespCommandArgument.Key(data.key),
@@ -639,14 +634,14 @@ object Input {
         RespCommandArgument.Value(data.id)
       )
 
-      RespCommand(if (data.mkStream) chunk :+ RespCommandArgument.Literal(MkStream.asString) else chunk)
+      RespCommandArguments(if (data.mkStream) chunk :+ RespCommandArgument.Literal(MkStream.asString) else chunk)
     }
   }
 
   final case class XGroupDelConsumerInput[K: BinaryCodec, G: BinaryCodec, C: BinaryCodec]()
       extends Input[XGroupCommand.DelConsumer[K, G, C]] {
-    def encode(data: XGroupCommand.DelConsumer[K, G, C]): RespCommand =
-      RespCommand(
+    def encode(data: XGroupCommand.DelConsumer[K, G, C]): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Literal("DELCONSUMER"),
         RespCommandArgument.Key(data.key),
         RespCommandArgument.Value(data.group),
@@ -655,8 +650,8 @@ object Input {
   }
 
   final case class XGroupDestroyInput[K: BinaryCodec, G: BinaryCodec]() extends Input[XGroupCommand.Destroy[K, G]] {
-    def encode(data: XGroupCommand.Destroy[K, G]): RespCommand =
-      RespCommand(
+    def encode(data: XGroupCommand.Destroy[K, G]): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Literal("DESTROY"),
         RespCommandArgument.Key(data.key),
         RespCommandArgument.Value(data.group)
@@ -665,8 +660,8 @@ object Input {
 
   final case class XGroupSetIdInput[K: BinaryCodec, G: BinaryCodec, I: BinaryCodec]()
       extends Input[XGroupCommand.SetId[K, G, I]] {
-    def encode(data: XGroupCommand.SetId[K, G, I]): RespCommand =
-      RespCommand(
+    def encode(data: XGroupCommand.SetId[K, G, I]): RespCommandArguments =
+      RespCommandArguments(
         RespCommandArgument.Literal("SETID"),
         RespCommandArgument.Key(data.key),
         RespCommandArgument.Value(data.group),
diff --git a/modules/redis/src/main/scala/zio/redis/internal/ClusterExecutor.scala b/modules/redis/src/main/scala/zio/redis/internal/ClusterExecutor.scala
index d0929e772..ef31b005c 100644
--- a/modules/redis/src/main/scala/zio/redis/internal/ClusterExecutor.scala
+++ b/modules/redis/src/main/scala/zio/redis/internal/ClusterExecutor.scala
@@ -58,7 +58,7 @@ private[redis] final class ClusterExecutor private (
     }
 
     for {
-      keyOpt <- ZIO.succeed(command.args.collectFirst { case key: RespCommandArgument.Key => key })
+      keyOpt <- ZIO.succeed(command.args.values.collectFirst { case key: RespCommandArgument.Key => key })
       keySlot = keyOpt.fold(Slot.Default)(key => Slot((key.asCRC16 & (SlotsAmount - 1)).toLong))
       result <- executeSafe(keySlot)
     } yield result
diff --git a/modules/redis/src/main/scala/zio/redis/internal/RedisCommand.scala b/modules/redis/src/main/scala/zio/redis/internal/RedisCommand.scala
index 84d30e55c..8b951908a 100644
--- a/modules/redis/src/main/scala/zio/redis/internal/RedisCommand.scala
+++ b/modules/redis/src/main/scala/zio/redis/internal/RedisCommand.scala
@@ -17,7 +17,6 @@
 package zio.redis.internal
 
 import zio._
-import zio.redis.Input.{CommandNameInput, Varargs}
 import zio.redis._
 
 private[redis] final class RedisCommand[-In, +Out] private (
@@ -33,7 +32,7 @@ private[redis] final class RedisCommand[-In, +Out] private (
       .refineToOrDie[RedisError]
 
   def resp(in: In): RespCommand =
-    Varargs(CommandNameInput).encode(name.split(" ")) ++ input.encode(in)
+    RespCommand(RespCommandName(name), input.encode(in))
 }
 
 private[redis] object RedisCommand {
diff --git a/modules/redis/src/main/scala/zio/redis/internal/RespCommand.scala b/modules/redis/src/main/scala/zio/redis/internal/RespCommand.scala
index 82e3bf6b3..2b65a4213 100644
--- a/modules/redis/src/main/scala/zio/redis/internal/RespCommand.scala
+++ b/modules/redis/src/main/scala/zio/redis/internal/RespCommand.scala
@@ -18,18 +18,30 @@ package zio.redis.internal
 
 import zio.Chunk
 
-private[redis] final case class RespCommand(args: Chunk[RespCommandArgument]) extends AnyVal {
-  def ++(that: RespCommand): RespCommand = RespCommand(this.args ++ that.args)
+private[redis] final case class RespCommand(name: RespCommandName, args: RespCommandArguments) {
+  def bulkStrings: Chunk[RespValue.BulkString] = name.bulkStrings ++ args.bulkStrings
+}
+
+private[redis] final case class RespCommandName(str: String) extends AnyVal {
+  def bulkStrings: Chunk[RespValue.BulkString] = Chunk.fromArray(str.split(" ").map(RespValue.bulkString))
+}
+
+private[redis] final case class RespCommandArguments(values: Chunk[RespCommandArgument]) extends AnyVal {
+  def ++(that: RespCommandArguments): RespCommandArguments = RespCommandArguments(this.values ++ that.values)
+
+  def map(f: RespCommandArgument => RespCommandArgument): RespCommandArguments = RespCommandArguments(
+    values.map(f(_))
+  )
 
-  def mapArguments(f: RespCommandArgument => RespCommandArgument): RespCommand = RespCommand(args.map(f(_)))
+  def bulkStrings: Chunk[RespValue.BulkString] = values.map(_.value)
 }
 
-private[redis] object RespCommand {
-  def empty: RespCommand = new RespCommand(Chunk.empty)
+private[redis] object RespCommandArguments {
+  def empty: RespCommandArguments = new RespCommandArguments(Chunk.empty)
 
-  def apply(args: Chunk[RespCommandArgument]): RespCommand = new RespCommand(args)
+  def apply(args: Chunk[RespCommandArgument]): RespCommandArguments = new RespCommandArguments(args)
 
-  def apply(args: RespCommandArgument*): RespCommand = new RespCommand(Chunk.fromIterable(args))
+  def apply(args: RespCommandArgument*): RespCommandArguments = new RespCommandArguments(Chunk.fromIterable(args))
 
-  def apply(arg: RespCommandArgument): RespCommand = new RespCommand(Chunk.single(arg))
+  def apply(arg: RespCommandArgument): RespCommandArguments = new RespCommandArguments(Chunk.single(arg))
 }
diff --git a/modules/redis/src/main/scala/zio/redis/internal/RespCommandArgument.scala b/modules/redis/src/main/scala/zio/redis/internal/RespCommandArgument.scala
index 0bf226aad..648ca6a32 100644
--- a/modules/redis/src/main/scala/zio/redis/internal/RespCommandArgument.scala
+++ b/modules/redis/src/main/scala/zio/redis/internal/RespCommandArgument.scala
@@ -26,11 +26,6 @@ private[redis] sealed trait RespCommandArgument {
 }
 
 private[redis] object RespCommandArgument {
-
-  final case class CommandName(str: String) extends RespCommandArgument {
-    lazy val value: RespValue.BulkString = RespValue.bulkString(str)
-  }
-
   final case class Literal(str: String) extends RespCommandArgument {
     lazy val value: RespValue.BulkString = RespValue.bulkString(str)
   }
diff --git a/modules/redis/src/main/scala/zio/redis/internal/SingleNodeExecutor.scala b/modules/redis/src/main/scala/zio/redis/internal/SingleNodeExecutor.scala
index 4b13a07db..76fd76470 100644
--- a/modules/redis/src/main/scala/zio/redis/internal/SingleNodeExecutor.scala
+++ b/modules/redis/src/main/scala/zio/redis/internal/SingleNodeExecutor.scala
@@ -30,7 +30,7 @@ private[redis] final class SingleNodeExecutor private (
   def execute(command: RespCommand): IO[RedisError, RespValue] =
     Promise
       .make[RedisError, RespValue]
-      .flatMap(promise => requests.offer(Request(command.args.map(_.value), promise)) *> promise.await)
+      .flatMap(promise => requests.offer(Request(command.bulkStrings, promise)) *> promise.await)
 
   /**
    * Opens a connection to the server and launches send and receive operations. All failures are retried by opening a
diff --git a/modules/redis/src/test/scala/zio/redis/InputSpec.scala b/modules/redis/src/test/scala/zio/redis/InputSpec.scala
index 50c90d7f5..8c4f6ce0c 100644
--- a/modules/redis/src/test/scala/zio/redis/InputSpec.scala
+++ b/modules/redis/src/test/scala/zio/redis/InputSpec.scala
@@ -2,7 +2,7 @@ package zio.redis
 
 import zio._
 import zio.redis.Input._
-import zio.redis.internal.RespCommand
+import zio.redis.internal.RespCommandArguments
 import zio.redis.internal.RespCommandArgument._
 import zio.test.Assertion._
 import zio.test._
@@ -24,7 +24,7 @@ object InputSpec extends BaseSpec {
         test("valid value") {
           for {
             result <- ZIO.attempt(AbsTtlInput.encode(AbsTtl))
-          } yield assert(result)(equalTo(RespCommand(Literal("ABSTTL"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("ABSTTL"))))
         }
       ),
       suite("Address")(
@@ -33,86 +33,86 @@ object InputSpec extends BaseSpec {
             ip     <- ZIO.succeed(InetAddress.getByName("127.0.0.1"))
             port   <- ZIO.succeed(42)
             result <- ZIO.attempt(AddressInput.encode(Address(ip, port)))
-          } yield assert(result)(equalTo(RespCommand(Value("127.0.0.1:42"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("127.0.0.1:42"))))
         }
       ),
       suite("Aggregate")(
         test("max") {
           for {
             result <- ZIO.attempt(AggregateInput.encode(Aggregate.Max))
-          } yield assert(result)(equalTo(RespCommand(Literal("AGGREGATE"), Literal("MAX"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("AGGREGATE"), Literal("MAX"))))
         },
         test("min") {
           for {
             result <- ZIO.attempt(AggregateInput.encode(Aggregate.Min))
-          } yield assert(result)(equalTo(RespCommand(Literal("AGGREGATE"), Literal("MIN"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("AGGREGATE"), Literal("MIN"))))
         },
         test("sum") {
           for {
             result <- ZIO.attempt(AggregateInput.encode(Aggregate.Sum))
-          } yield assert(result)(equalTo(RespCommand(Literal("AGGREGATE"), Literal("SUM"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("AGGREGATE"), Literal("SUM"))))
         }
       ),
       suite("Alpha")(
         test("alpha") {
           for {
             result <- ZIO.attempt(AlphaInput.encode(Alpha))
-          } yield assert(result)(equalTo(RespCommand(Literal("ALPHA"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("ALPHA"))))
         }
       ),
       suite("Auth")(
         test("with empty password") {
           for {
             result <- ZIO.attempt(AuthInput.encode(Auth(None, "")))
-          } yield assert(result)(equalTo(RespCommand(Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value(""))))
         },
         test("with non-empty password") {
           for {
             result <- ZIO.attempt(AuthInput.encode(Auth(None, "pass")))
-          } yield assert(result)(equalTo(RespCommand(Value("pass"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("pass"))))
         },
         test("with both username and password") {
           for {
             result <- ZIO.attempt(AuthInput.encode(Auth(Some("user"), "pass")))
-          } yield assert(result)(equalTo(RespCommand(Value("user"), Value("pass"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("user"), Value("pass"))))
         }
       ),
       suite("Bool")(
         test("true") {
           for {
             result <- ZIO.attempt(BoolInput.encode(true))
-          } yield assert(result)(equalTo(RespCommand(Literal("1"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("1"))))
         },
         test("false") {
           for {
             result <- ZIO.attempt(BoolInput.encode(false))
-          } yield assert(result)(equalTo(RespCommand(Literal("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("0"))))
         }
       ),
       suite("LcsQueryType")(
         test("length option") {
           assert(LcsQueryTypeInput.encode(LcsQueryType.Len))(
-            equalTo(RespCommand(Literal("LEN")))
+            equalTo(RespCommandArguments(Literal("LEN")))
           )
         },
         test("idx option default") {
           assert(LcsQueryTypeInput.encode(Idx()))(
-            equalTo(RespCommand(Literal("IDX")))
+            equalTo(RespCommandArguments(Literal("IDX")))
           )
         },
         test("idx option with minmatchlength") {
           assert(LcsQueryTypeInput.encode(Idx(minMatchLength = 2)))(
-            equalTo(RespCommand(Literal("IDX"), Literal("MINMATCHLEN"), Value("2")))
+            equalTo(RespCommandArguments(Literal("IDX"), Literal("MINMATCHLEN"), Value("2")))
           )
         },
         test("idx option with withmatchlength") {
           assert(LcsQueryTypeInput.encode(Idx(withMatchLength = true)))(
-            equalTo(RespCommand(Literal("IDX"), Literal("WITHMATCHLEN")))
+            equalTo(RespCommandArguments(Literal("IDX"), Literal("WITHMATCHLEN")))
           )
         },
         test("idx option with minmatchlength and withmatchlength") {
           assert(LcsQueryTypeInput.encode(Idx(minMatchLength = 2, withMatchLength = true)))(
-            equalTo(RespCommand(Literal("IDX"), Literal("MINMATCHLEN"), Value("2"), Literal("WITHMATCHLEN")))
+            equalTo(RespCommandArguments(Literal("IDX"), Literal("MINMATCHLEN"), Value("2"), Literal("WITHMATCHLEN")))
           )
         }
       ),
@@ -120,305 +120,305 @@ object InputSpec extends BaseSpec {
         test("get with unsigned type and positive offset") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldGet(UnsignedInt(3), 2)))
-          } yield assert(result)(equalTo(RespCommand(Literal("GET"), Value("u3"), Value("2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("GET"), Value("u3"), Value("2"))))
         },
         test("get with signed type and negative offset") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldGet(SignedInt(3), -2)))
-          } yield assert(result)(equalTo(RespCommand(Literal("GET"), Value("i3"), Value("-2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("GET"), Value("i3"), Value("-2"))))
         },
         test("get with unsigned type and zero offset") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldGet(UnsignedInt(3), 0)))
-          } yield assert(result)(equalTo(RespCommand(Literal("GET"), Value("u3"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("GET"), Value("u3"), Value("0"))))
         },
         test("set with unsigned type, positive offset and positive value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldSet(UnsignedInt(3), 2, 100L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("SET"), Value("u3"), Value("2"), Value("100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("SET"), Value("u3"), Value("2"), Value("100"))))
         },
         test("set with signed type, negative offset and negative value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldSet(SignedInt(3), -2, -100L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("SET"), Value("i3"), Value("-2"), Value("-100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("SET"), Value("i3"), Value("-2"), Value("-100"))))
         },
         test("set with unsigned type, zero offset and zero value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldSet(UnsignedInt(3), 0, 0L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("SET"), Value("u3"), Value("0"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("SET"), Value("u3"), Value("0"), Value("0"))))
         },
         test("incr with unsigned type, positive offset and positive value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldIncr(UnsignedInt(3), 2, 100L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("INCRBY"), Value("u3"), Value("2"), Value("100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("INCRBY"), Value("u3"), Value("2"), Value("100"))))
         },
         test("incr with signed type, negative offset and negative value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldIncr(SignedInt(3), -2, -100L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("INCRBY"), Value("i3"), Value("-2"), Value("-100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("INCRBY"), Value("i3"), Value("-2"), Value("-100"))))
         },
         test("incr with unsigned type, zero offset and zero value") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldIncr(UnsignedInt(3), 0, 0L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("INCRBY"), Value("u3"), Value("0"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("INCRBY"), Value("u3"), Value("0"), Value("0"))))
         },
         test("overflow sat") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldOverflow.Sat))
-          } yield assert(result)(equalTo(RespCommand(Literal("OVERFLOW"), Literal("SAT"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("OVERFLOW"), Literal("SAT"))))
         },
         test("overflow fail") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldOverflow.Fail))
-          } yield assert(result)(equalTo(RespCommand(Literal("OVERFLOW"), Literal("FAIL"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("OVERFLOW"), Literal("FAIL"))))
         },
         test("overflow warp") {
           for {
             result <- ZIO.attempt(BitFieldCommandInput.encode(BitFieldOverflow.Wrap))
-          } yield assert(result)(equalTo(RespCommand(Literal("OVERFLOW"), Literal("WRAP"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("OVERFLOW"), Literal("WRAP"))))
         }
       ),
       suite("BitOperation")(
         test("and") {
           for {
             result <- ZIO.attempt(BitOperationInput.encode(AND))
-          } yield assert(result)(equalTo(RespCommand(Literal("AND"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("AND"))))
         },
         test("or") {
           for {
             result <- ZIO.attempt(BitOperationInput.encode(OR))
-          } yield assert(result)(equalTo(RespCommand(Literal("OR"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("OR"))))
         },
         test("xor") {
           for {
             result <- ZIO.attempt(BitOperationInput.encode(XOR))
-          } yield assert(result)(equalTo(RespCommand(Literal("XOR"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("XOR"))))
         },
         test("not") {
           for {
             result <- ZIO.attempt(BitOperationInput.encode(NOT))
-          } yield assert(result)(equalTo(RespCommand(Literal("NOT"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("NOT"))))
         }
       ),
       suite("BitPosRange")(
         test("with only start") {
           for {
             result <- ZIO.attempt(BitPosRangeInput.encode(BitPosRange(1.second.toMillis, None)))
-          } yield assert(result)(equalTo(RespCommand(Value("1000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1000"))))
         },
         test("with start and the end") {
           for {
             result <- ZIO.attempt(BitPosRangeInput.encode(BitPosRange(0.second.toMillis, Some(1.second.toMillis))))
-          } yield assert(result)(equalTo(RespCommand(Value("0"), Value("1000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"), Value("1000"))))
         }
       ),
       suite("By")(
         test("with a pattern") {
           for {
             result <- ZIO.attempt(ByInput.encode("mykey_*"))
-          } yield assert(result)(equalTo(RespCommand(Literal("BY"), Value("mykey_*"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("BY"), Value("mykey_*"))))
         }
       ),
       suite("Changed")(
         test("valid value") {
           for {
             result <- ZIO.attempt(ChangedInput.encode(Changed))
-          } yield assert(result)(equalTo(RespCommand(Literal("CH"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("CH"))))
         }
       ),
       suite("Copy")(
         test("valid value") {
           for {
             result <- ZIO.attempt(CopyInput.encode(Copy))
-          } yield assert(result)(equalTo(RespCommand(Literal("COPY"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("COPY"))))
         }
       ),
       suite("Count")(
         test("positive value") {
           for {
             result <- ZIO.attempt(CountInput.encode(Count(3L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("COUNT"), Value("3"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("COUNT"), Value("3"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(CountInput.encode(Count(-3L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("COUNT"), Value("-3"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("COUNT"), Value("-3"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(CountInput.encode(Count(0L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("COUNT"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("COUNT"), Value("0"))))
         }
       ),
       suite("Position")(
         test("before") {
           for {
             result <- ZIO.attempt(PositionInput.encode(Position.Before))
-          } yield assert(result)(equalTo(RespCommand(Literal("BEFORE"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("BEFORE"))))
         },
         test("after") {
           for {
             result <- ZIO.attempt(PositionInput.encode(Position.After))
-          } yield assert(result)(equalTo(RespCommand(Literal("AFTER"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("AFTER"))))
         }
       ),
       suite("RedisType")(
         test("string type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.String))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("string"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("string"))))
         },
         test("list type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.List))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("list"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("list"))))
         },
         test("set type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.Set))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("set"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("set"))))
         },
         test("sorted set type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.SortedSet))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("zset"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("zset"))))
         },
         test("hash type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.Hash))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("hash"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("hash"))))
         },
         test("stream type") {
           for {
             result <- ZIO.attempt(RedisTypeInput.encode(RedisType.Stream))
-          } yield assert(result)(equalTo(RespCommand(Literal("TYPE"), Literal("stream"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("TYPE"), Literal("stream"))))
         }
       ),
       suite("Double")(
         test("positive value") {
           for {
             result <- ZIO.attempt(DoubleInput.encode(4.2d))
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(DoubleInput.encode(-4.2d))
-          } yield assert(result)(equalTo(RespCommand(Value("-4.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4.2"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(DoubleInput.encode(0d))
-          } yield assert(result)(equalTo(RespCommand(Value("0.0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0.0"))))
         }
       ),
       suite("DurationMilliseconds")(
         test("1 second") {
           for {
             result <- ZIO.attempt(DurationMillisecondsInput.encode(1.second))
-          } yield assert(result)(equalTo(RespCommand(Value("1000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1000"))))
         },
         test("100 milliseconds") {
           for {
             result <- ZIO.attempt(DurationMillisecondsInput.encode(100.millis))
-          } yield assert(result)(equalTo(RespCommand(Value("100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("100"))))
         }
       ),
       suite("DurationSeconds")(
         test("1 minute") {
           for {
             result <- ZIO.attempt(DurationSecondsInput.encode(1.minute))
-          } yield assert(result)(equalTo(RespCommand(Value("60"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("60"))))
         },
         test("1 second") {
           for {
             result <- ZIO.attempt(DurationSecondsInput.encode(1.second))
-          } yield assert(result)(equalTo(RespCommand(Value("1"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1"))))
         },
         test("100 milliseconds") {
           for {
             result <- ZIO.attempt(DurationSecondsInput.encode(100.millis))
-          } yield assert(result)(equalTo(RespCommand(Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"))))
         }
       ),
       suite("DurationTtl")(
         test("1 second") {
           for {
             result <- ZIO.attempt(DurationTtlInput.encode(1.second))
-          } yield assert(result)(equalTo(RespCommand(Literal("PX"), Value("1000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("PX"), Value("1000"))))
         },
         test("100 milliseconds") {
           for {
             result <- ZIO.attempt(DurationTtlInput.encode(100.millis))
-          } yield assert(result)(equalTo(RespCommand(Literal("PX"), Value("100"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("PX"), Value("100"))))
         }
       ),
       suite("Freq")(
         test("empty string") {
           for {
             result <- ZIO.attempt(FreqInput.encode(Freq("")))
-          } yield assert(result)(equalTo(RespCommand(Literal("FREQ"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("FREQ"), Value(""))))
         },
         test("non-empty string") {
           for {
             result <- ZIO.attempt(FreqInput.encode(Freq("frequency")))
-          } yield assert(result)(equalTo(RespCommand(Literal("FREQ"), Value("frequency"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("FREQ"), Value("frequency"))))
         }
       ),
       suite("Get")(
         test("with a pattern") {
           for {
             result <- ZIO.attempt(GetInput.encode("mypattern_*"))
-          } yield assert(result)(equalTo(RespCommand(Literal("GET"), Value("mypattern_*"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("GET"), Value("mypattern_*"))))
         }
       ),
       suite("GetKeyword")(
         test("valid value") {
           for {
             result <- ZIO.attempt(GetKeywordInput.encode(GetKeyword))
-          } yield assert(result)(equalTo(RespCommand(Literal("GET"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("GET"))))
         }
       ),
       suite("IdleTime")(
         test("0 seconds") {
           for {
             result <- ZIO.attempt(IdleTimeInput.encode(IdleTime(0)))
-          } yield assert(result)(equalTo(RespCommand(Literal("IDLETIME"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("IDLETIME"), Value("0"))))
         },
         test("5 seconds") {
           for {
             result <- ZIO.attempt(IdleTimeInput.encode(IdleTime(5)))
-          } yield assert(result)(equalTo(RespCommand(Literal("IDLETIME"), Value("5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("IDLETIME"), Value("5"))))
         }
       ),
       suite("Increment")(
         test("valid value") {
           for {
             result <- ZIO.attempt(IncrementInput.encode(Increment))
-          } yield assert(result)(equalTo(RespCommand(Literal("INCR"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("INCR"))))
         }
       ),
       suite("Int")(
         test("positive value") {
           for {
             result <- ZIO.attempt(IntInput.encode(4))
-          } yield assert(result)(equalTo(RespCommand(Value("4"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(IntInput.encode(-4))
-          } yield assert(result)(equalTo(RespCommand(Value("-4"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(IntInput.encode(0))
-          } yield assert(result)(equalTo(RespCommand(Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"))))
         }
       ),
       suite("KeepTtl")(
         test("valid value") {
           for {
             result <- ZIO.attempt(KeepTtlInput.encode(KeepTtl))
-          } yield assert(result)(equalTo(RespCommand(Literal("KEEPTTL"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("KEEPTTL"))))
         }
       ),
       suite("LexRange")(
@@ -428,7 +428,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Unbounded.asString, LexMaximum.Unbounded.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-"), Value("+"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-"), Value("+"))))
         },
         test("with open min and unbound max") {
           for {
@@ -436,7 +436,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Open("a").asString, LexMaximum.Unbounded.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(a"), Value("+"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(a"), Value("+"))))
         },
         test("with closed min and unbound max") {
           for {
@@ -444,7 +444,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Closed("a").asString, LexMaximum.Unbounded.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("[a"), Value("+"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("[a"), Value("+"))))
         },
         test("with unbound min and open max") {
           for {
@@ -452,7 +452,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Unbounded.asString, LexMaximum.Open("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-"), Value("(z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-"), Value("(z"))))
         },
         test("with open min and open max") {
           for {
@@ -460,7 +460,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Open("a").asString, LexMaximum.Open("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(a"), Value("(z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(a"), Value("(z"))))
         },
         test("with closed min and open max") {
           for {
@@ -468,7 +468,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Closed("a").asString, LexMaximum.Open("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("[a"), Value("(z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("[a"), Value("(z"))))
         },
         test("with unbound min and closed max") {
           for {
@@ -476,7 +476,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Unbounded.asString, LexMaximum.Closed("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-"), Value("[z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-"), Value("[z"))))
         },
         test("with open min and closed max") {
           for {
@@ -484,7 +484,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Open("a").asString, LexMaximum.Closed("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(a"), Value("[z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(a"), Value("[z"))))
         },
         test("with closed min and closed max") {
           for {
@@ -492,208 +492,208 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((LexMinimum.Closed("a").asString, LexMaximum.Closed("z").asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("[a"), Value("[z"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("[a"), Value("[z"))))
         }
       ),
       suite("Limit")(
         test("with positive offset and positive count") {
           for {
             result <- ZIO.attempt(LimitInput.encode(Limit(4L, 5L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("LIMIT"), Value("4"), Value("5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("LIMIT"), Value("4"), Value("5"))))
         },
         test("with negative offset and negative count") {
           for {
             result <- ZIO.attempt(LimitInput.encode(Limit(-4L, -5L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("LIMIT"), Value("-4"), Value("-5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("LIMIT"), Value("-4"), Value("-5"))))
         },
         test("with zero offset and zero count") {
           for {
             result <- ZIO.attempt(LimitInput.encode(Limit(0L, 0L)))
-          } yield assert(result)(equalTo(RespCommand(Literal("LIMIT"), Value("0"), Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("LIMIT"), Value("0"), Value("0"))))
         }
       ),
       suite("Long")(
         test("positive value") {
           for {
             result <- ZIO.attempt(LongInput.encode(4L))
-          } yield assert(result)(equalTo(RespCommand(Value("4"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(LongInput.encode(-4L))
-          } yield assert(result)(equalTo(RespCommand(Value("-4"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(LongInput.encode(0L))
-          } yield assert(result)(equalTo(RespCommand(Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"))))
         }
       ),
       suite("LongLat")(
         test("positive longitude and latitude") {
           for {
             result <- ZIO.attempt(LongLatInput.encode(LongLat(4.2d, 5.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value("5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value("5.2"))))
         },
         test("negative longitude and latitude") {
           for {
             result <- ZIO.attempt(LongLatInput.encode(LongLat(-4.2d, -5.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("-4.2"), Value("-5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4.2"), Value("-5.2"))))
         },
         test("zero longitude and latitude") {
           for {
             result <- ZIO.attempt(LongLatInput.encode(LongLat(0d, 0d)))
-          } yield assert(result)(equalTo(RespCommand(Value("0.0"), Value("0.0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0.0"), Value("0.0"))))
         }
       ),
       suite("MemberScore")(
         test("with positive score and empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("", 4.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value(""))))
         },
         test("with negative score and empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("", -4.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("-4.2"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4.2"), Value(""))))
         },
         test("with zero score and empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("", 0d)))
-          } yield assert(result)(equalTo(RespCommand(Value("0.0"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0.0"), Value(""))))
         },
         test("with positive score and non-empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("member", 4.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value("member"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value("member"))))
         },
         test("with negative score and non-empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("member", -4.2d)))
-          } yield assert(result)(equalTo(RespCommand(Value("-4.2"), Value("member"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-4.2"), Value("member"))))
         },
         test("with zero score and non-empty member") {
           for {
             result <- ZIO.attempt(MemberScoreInput[String]().encode(MemberScore("member", 0d)))
-          } yield assert(result)(equalTo(RespCommand(Value("0.0"), Value("member"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0.0"), Value("member"))))
         }
       ),
       suite("NoInput")(
         test("valid value") {
           for {
             result <- ZIO.attempt(NoInput.encode(()))
-          } yield assert(result.args)(isEmpty)
+          } yield assert(result.values)(isEmpty)
         }
       ),
       suite("NonEmptyList")(
         test("with multiple elements") {
           for {
             result <- ZIO.attempt(NonEmptyList(StringInput).encode(("a", List("b", "c"))))
-          } yield assert(result)(equalTo(RespCommand(Value("a"), Value("b"), Value("c"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("a"), Value("b"), Value("c"))))
         },
         test("with one element") {
           for {
             result <- ZIO.attempt(NonEmptyList(StringInput).encode(("a", List.empty)))
-          } yield assert(result)(equalTo(RespCommand(Value("a"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("a"))))
         }
       ),
       suite("Order")(
         test("ascending") {
           for {
             result <- ZIO.attempt(OrderInput.encode(Ascending))
-          } yield assert(result)(equalTo(RespCommand(Value("ASC"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("ASC"))))
         },
         test("descending") {
           for {
             result <- ZIO.attempt(OrderInput.encode(Descending))
-          } yield assert(result)(equalTo(RespCommand(Value("DESC"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("DESC"))))
         }
       ),
       suite("RadiusUnit")(
         test("meters") {
           for {
             result <- ZIO.attempt(RadiusUnitInput.encode(Meters))
-          } yield assert(result)(equalTo(RespCommand(Value("m"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("m"))))
         },
         test("kilometers") {
           for {
             result <- ZIO.attempt(RadiusUnitInput.encode(Kilometers))
-          } yield assert(result)(equalTo(RespCommand(Value("km"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("km"))))
         },
         test("feet") {
           for {
             result <- ZIO.attempt(RadiusUnitInput.encode(Feet))
-          } yield assert(result)(equalTo(RespCommand(Value("ft"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("ft"))))
         },
         test("miles") {
           for {
             result <- ZIO.attempt(RadiusUnitInput.encode(Miles))
-          } yield assert(result)(equalTo(RespCommand(Value("mi"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("mi"))))
         }
       ),
       suite("Range")(
         test("with positive start and positive end") {
           for {
             result <- ZIO.attempt(RangeInput.encode(Range(1, 5)))
-          } yield assert(result)(equalTo(RespCommand(Value("1"), Value("5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1"), Value("5"))))
         },
         test("with negative start and positive end") {
           for {
             result <- ZIO.attempt(RangeInput.encode(Range(-1, 5)))
-          } yield assert(result)(equalTo(RespCommand(Value("-1"), Value("5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-1"), Value("5"))))
         },
         test("with positive start and negative end") {
           for {
             result <- ZIO.attempt(RangeInput.encode(Range(1, -5)))
-          } yield assert(result)(equalTo(RespCommand(Value("1"), Value("-5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1"), Value("-5"))))
         },
         test("with negative start and negative end") {
           for {
             result <- ZIO.attempt(RangeInput.encode(Range(-1, -5)))
-          } yield assert(result)(equalTo(RespCommand(Value("-1"), Value("-5"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-1"), Value("-5"))))
         }
       ),
       suite("Pattern")(
         test("with valid pattern") {
           for {
             result <- ZIO.attempt(PatternInput.encode(Pattern("*[ab]-*")))
-          } yield assert(result)(equalTo(RespCommand(Literal("MATCH"), Value("*[ab]-*"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("MATCH"), Value("*[ab]-*"))))
         },
         test("with empty pattern") {
           for {
             result <- ZIO.attempt(PatternInput.encode(Pattern("")))
-          } yield assert(result)(equalTo(RespCommand(Literal("MATCH"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("MATCH"), Value(""))))
         }
       ),
       suite("Replace")(
         test("valid value") {
           for {
             result <- ZIO.attempt(ReplaceInput.encode(Replace))
-          } yield assert(result)(equalTo(RespCommand(Literal("REPLACE"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("REPLACE"))))
         }
       ),
       suite("StoreDist")(
         test("with non-empty string") {
           for {
             result <- ZIO.attempt(StoreDistInput.encode(StoreDist("key")))
-          } yield assert(result)(equalTo(RespCommand(Literal("STOREDIST"), Value("key"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("STOREDIST"), Value("key"))))
         },
         test("with empty string") {
           for {
             result <- ZIO.attempt(StoreDistInput.encode(StoreDist("")))
-          } yield assert(result)(equalTo(RespCommand(Literal("STOREDIST"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("STOREDIST"), Value(""))))
         }
       ),
       suite("Store")(
         test("with non-empty string") {
           for {
             result <- ZIO.attempt(StoreInput.encode(Store("key")))
-          } yield assert(result)(equalTo(RespCommand(Literal("STORE"), Value("key"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("STORE"), Value("key"))))
         },
         test("with empty string") {
           for {
             result <- ZIO.attempt(StoreInput.encode(Store("")))
-          } yield assert(result)(equalTo(RespCommand(Literal("STORE"), Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("STORE"), Value(""))))
         }
       ),
       suite("ScoreRange")(
@@ -703,7 +703,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Infinity.asString, ScoreMaximum.Infinity.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-inf"), Value("+inf"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-inf"), Value("+inf"))))
         },
         test("with open min and infinite max") {
           for {
@@ -711,7 +711,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Open(4.2d).asString, ScoreMaximum.Infinity.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(4.2"), Value("+inf"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(4.2"), Value("+inf"))))
         },
         test("with closed min and infinite max") {
           for {
@@ -719,7 +719,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Closed(4.2d).asString, ScoreMaximum.Infinity.asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value("+inf"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value("+inf"))))
         },
         test("with infinite min and open max") {
           for {
@@ -727,7 +727,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Infinity.asString, ScoreMaximum.Open(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-inf"), Value("(5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-inf"), Value("(5.2"))))
         },
         test("with open min and open max") {
           for {
@@ -735,7 +735,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Open(4.2d).asString, ScoreMaximum.Open(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(4.2"), Value("(5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(4.2"), Value("(5.2"))))
         },
         test("with closed min and open max") {
           for {
@@ -743,7 +743,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Closed(4.2d).asString, ScoreMaximum.Open(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value("(5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value("(5.2"))))
         },
         test("with infinite min and closed max") {
           for {
@@ -751,7 +751,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Infinity.asString, ScoreMaximum.Closed(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("-inf"), Value("5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-inf"), Value("5.2"))))
         },
         test("with open min and closed max") {
           for {
@@ -759,7 +759,7 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Open(4.2d).asString, ScoreMaximum.Closed(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("(4.2"), Value("5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("(4.2"), Value("5.2"))))
         },
         test("with closed min and closed max") {
           for {
@@ -767,115 +767,115 @@ object InputSpec extends BaseSpec {
                         Tuple2(ArbitraryValueInput[String](), ArbitraryValueInput[String]())
                           .encode((ScoreMinimum.Closed(4.2d).asString, ScoreMaximum.Closed(5.2d).asString))
                       )
-          } yield assert(result)(equalTo(RespCommand(Value("4.2"), Value("5.2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("4.2"), Value("5.2"))))
         }
       ),
       suite("ScriptDebug")(
         test("yes") {
           for {
             result <- ZIO.attempt(ScriptDebugInput.encode(DebugMode.Yes))
-          } yield assert(result)(equalTo(RespCommand(Literal("YES"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("YES"))))
         },
         test("sync") {
           for {
             result <- ZIO.attempt(ScriptDebugInput.encode(DebugMode.Sync))
-          } yield assert(result)(equalTo(RespCommand(Literal("SYNC"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("SYNC"))))
         },
         test("no") {
           for {
             result <- ZIO.attempt(ScriptDebugInput.encode(DebugMode.No))
-          } yield assert(result)(equalTo(RespCommand(Literal("NO"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("NO"))))
         }
       ),
       suite("ScriptFlush")(
         test("asynchronous") {
           for {
             result <- ZIO.attempt(ScriptFlushInput.encode(FlushMode.Async))
-          } yield assert(result)(equalTo(RespCommand(Literal("ASYNC"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("ASYNC"))))
         },
         test("synchronous") {
           for {
             result <- ZIO.attempt(ScriptFlushInput.encode(FlushMode.Sync))
-          } yield assert(result)(equalTo(RespCommand(Literal("SYNC"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("SYNC"))))
         }
       ),
       suite("String")(
         test("non-empty value") {
           for {
             result <- ZIO.attempt(StringInput.encode("non-empty"))
-          } yield assert(result)(equalTo(RespCommand(Value("non-empty"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("non-empty"))))
         },
         test("empty value") {
           for {
             result <- ZIO.attempt(StringInput.encode(""))
-          } yield assert(result)(equalTo(RespCommand(Value(""))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value(""))))
         }
       ),
       suite("Optional")(
         test("none") {
           for {
             result <- ZIO.attempt(OptionalInput(LongInput).encode(None))
-          } yield assert(result.args)(isEmpty)
+          } yield assert(result.values)(isEmpty)
         },
         test("some") {
           for {
             result <- ZIO.attempt(OptionalInput(LongInput).encode(Some(2L)))
-          } yield assert(result)(equalTo(RespCommand(Value("2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("2"))))
         }
       ),
       suite("TimeSeconds")(
         test("positiv value") {
           for {
             result <- ZIO.attempt(TimeSecondsInput.encode(Instant.ofEpochSecond(3L)))
-          } yield assert(result)(equalTo(RespCommand(Value("3"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("3"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(TimeSecondsInput.encode(Instant.ofEpochSecond(0L)))
-          } yield assert(result)(equalTo(RespCommand(Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(TimeSecondsInput.encode(Instant.ofEpochSecond(-3L)))
-          } yield assert(result)(equalTo(RespCommand(Value("-3"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-3"))))
         }
       ),
       suite("TimeMilliseconds")(
         test("positiv value") {
           for {
             result <- ZIO.attempt(TimeMillisecondsInput.encode(Instant.ofEpochSecond(3L)))
-          } yield assert(result)(equalTo(RespCommand(Value("3000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("3000"))))
         },
         test("zero value") {
           for {
             result <- ZIO.attempt(TimeMillisecondsInput.encode(Instant.ofEpochSecond(0L)))
-          } yield assert(result)(equalTo(RespCommand(Value("0"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("0"))))
         },
         test("negative value") {
           for {
             result <- ZIO.attempt(TimeMillisecondsInput.encode(Instant.ofEpochSecond(-3L)))
-          } yield assert(result)(equalTo(RespCommand(Value("-3000"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("-3000"))))
         }
       ),
       suite("Tuple2")(
         test("valid value") {
           for {
             result <- ZIO.attempt(Tuple2(StringInput, LongInput).encode(("one", 2L)))
-          } yield assert(result)(equalTo(RespCommand(Value("one"), Value("2"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("one"), Value("2"))))
         }
       ),
       suite("Tuple3")(
         test("valid value") {
           for {
             result <- ZIO.attempt(Tuple3(StringInput, LongInput, StringInput).encode(("one", 2, "three")))
-          } yield assert(result)(equalTo(RespCommand(Value("one"), Value("2"), Value("three"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("one"), Value("2"), Value("three"))))
         }
       ),
       suite("Tuple4")(
         test("valid value") {
           for {
             result <- ZIO.attempt(Tuple4(StringInput, LongInput, StringInput, LongInput).encode(("one", 2, "three", 4)))
-          } yield assert(result)(equalTo(RespCommand(Value("one"), Value("2"), Value("three"), Value("4"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("one"), Value("2"), Value("three"), Value("4"))))
         }
       ),
       suite("Tuple5")(
@@ -886,7 +886,7 @@ object InputSpec extends BaseSpec {
                           .encode(("one", 2, "three", 4, "five"))
                       )
           } yield assert(result)(
-            equalTo(RespCommand(Value("one"), Value("2"), Value("three"), Value("4"), Value("five")))
+            equalTo(RespCommandArguments(Value("one"), Value("2"), Value("three"), Value("4"), Value("five")))
           )
         }
       ),
@@ -899,7 +899,7 @@ object InputSpec extends BaseSpec {
                       )
           } yield assert(result)(
             equalTo(
-              RespCommand(
+              RespCommandArguments(
                 Value("one"),
                 Value("2"),
                 Value("three"),
@@ -930,7 +930,7 @@ object InputSpec extends BaseSpec {
                       )
           } yield assert(result)(
             equalTo(
-              RespCommand(
+              RespCommandArguments(
                 Value("one"),
                 Value("2"),
                 Value("three"),
@@ -965,7 +965,7 @@ object InputSpec extends BaseSpec {
                       )
           } yield assert(result)(
             equalTo(
-              RespCommand(
+              RespCommandArguments(
                 Value("one"),
                 Value("2"),
                 Value("three"),
@@ -986,32 +986,32 @@ object InputSpec extends BaseSpec {
         test("set existing") {
           for {
             result <- ZIO.attempt(UpdateInput.encode(Update.SetExisting))
-          } yield assert(result)(equalTo(RespCommand(Value("XX"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("XX"))))
         },
         test("set new") {
           for {
             result <- ZIO.attempt(UpdateInput.encode(Update.SetNew))
-          } yield assert(result)(equalTo(RespCommand(Value("NX"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("NX"))))
         }
       ),
       suite("Id")(
         test("valid value") {
           for {
             result <- ZIO.attempt(IdInput.encode(10))
-          } yield assert(result)(equalTo(RespCommand(Literal("ID"), Value("10"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("ID"), Value("10"))))
         }
       ),
       suite("IDs")(
         test("with a single element") {
           for {
             result <- ZIO.attempt(IdsInput.encode((1, Nil)))
-          } yield assert(result)(equalTo(RespCommand(Literal("ID"), Value("1"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("ID"), Value("1"))))
         },
         test("with multiple elements") {
           for {
             result <- ZIO.attempt(IdsInput.encode((1, List(2, 3, 4))))
           } yield assert(result)(
-            equalTo(RespCommand(Literal("ID"), Value("1"), Value("2"), Value("3"), Value("4")))
+            equalTo(RespCommandArguments(Literal("ID"), Value("1"), Value("2"), Value("3"), Value("4")))
           )
         }
       ),
@@ -1019,93 +1019,93 @@ object InputSpec extends BaseSpec {
         test("with multiple elements") {
           for {
             result <- ZIO.attempt(Varargs(LongInput).encode(List(1, 2, 3)))
-          } yield assert(result)(equalTo(RespCommand(Value("1"), Value("2"), Value("3"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Value("1"), Value("2"), Value("3"))))
         },
         test("with no elements") {
           for {
             result <- ZIO.attempt(Varargs(LongInput).encode(List.empty))
-          } yield assert(result.args)(isEmpty)
+          } yield assert(result.values)(isEmpty)
         }
       ),
       suite("WithScore")(
         test("valid value") {
           for {
             result <- ZIO.attempt(WithScoreInput.encode(WithScore))
-          } yield assert(result)(equalTo(RespCommand(Literal("WITHSCORE"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("WITHSCORE"))))
         }
       ),
       suite("WithScores")(
         test("valid value") {
           for {
             result <- ZIO.attempt(WithScoresInput.encode(WithScores))
-          } yield assert(result)(equalTo(RespCommand(Literal("WITHSCORES"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("WITHSCORES"))))
         }
       ),
       suite("WithCoord")(
         test("valid value") {
           for {
             result <- ZIO.attempt(WithCoordInput.encode(WithCoord))
-          } yield assert(result)(equalTo(RespCommand(Literal("WITHCOORD"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("WITHCOORD"))))
         }
       ),
       suite("WithDist")(
         test("valid value") {
           for {
             result <- ZIO.attempt(WithDistInput.encode(WithDist))
-          } yield assert(result)(equalTo(RespCommand(Literal("WITHDIST"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("WITHDIST"))))
         }
       ),
       suite("WithHash")(
         test("valid value") {
           for {
             result <- ZIO.attempt(WithHashInput.encode(WithHash))
-          } yield assert(result)(equalTo(RespCommand(Literal("WITHHASH"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("WITHHASH"))))
         }
       ),
       suite("Idle")(
         test("with 1 second") {
           ZIO
             .attempt(IdleInput.encode(1.second))
-            .map(assert(_)(equalTo(RespCommand(Literal("IDLE"), Value("1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("IDLE"), Value("1000")))))
         },
         test("with 100 milliseconds") {
           ZIO
             .attempt(IdleInput.encode(100.millis))
-            .map(assert(_)(equalTo(RespCommand(Literal("IDLE"), Value("100")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("IDLE"), Value("100")))))
         },
         test("with negative duration") {
           ZIO
             .attempt(IdleInput.encode((-1).second))
-            .map(assert(_)(equalTo(RespCommand(Literal("IDLE"), Value("-1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("IDLE"), Value("-1000")))))
         }
       ),
       suite("Time")(
         test("with 1 second") {
           ZIO
             .attempt(TimeInput.encode(1.second))
-            .map(assert(_)(equalTo(RespCommand(Literal("TIME"), Value("1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("TIME"), Value("1000")))))
         },
         test("with 100 milliseconds") {
           ZIO
             .attempt(TimeInput.encode(100.millis))
-            .map(assert(_)(equalTo(RespCommand(Literal("TIME"), Value("100")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("TIME"), Value("100")))))
         },
         test("with negative duration") {
           ZIO
             .attempt(TimeInput.encode((-1).second))
-            .map(assert(_)(equalTo(RespCommand(Literal("TIME"), Value("-1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("TIME"), Value("-1000")))))
         }
       ),
       suite("RetryCount")(
         test("with positive count") {
           ZIO
             .attempt(RetryCountInput.encode(100))
-            .map(assert(_)(equalTo(RespCommand(Literal("RETRYCOUNT"), Value("100")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("RETRYCOUNT"), Value("100")))))
         },
         test("with negative count") {
           ZIO
             .attempt(RetryCountInput.encode(-100))
-            .map(assert(_)(equalTo(RespCommand(Literal("RETRYCOUNT"), Value("-100")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("RETRYCOUNT"), Value("-100")))))
         }
       ),
       suite("XGroupCreate")(
@@ -1116,7 +1116,7 @@ object InputSpec extends BaseSpec {
                 XGroupCommand.Create("key", "group", "id", mkStream = false)
               )
             )
-            .map(assert(_)(equalTo(RespCommand(Literal("CREATE"), Key("key"), Value("group"), Value("id")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("CREATE"), Key("key"), Value("group"), Value("id")))))
         },
         test("with mkStream") {
           ZIO
@@ -1128,7 +1128,7 @@ object InputSpec extends BaseSpec {
             .map(
               assert(_)(
                 equalTo(
-                  RespCommand(Literal("CREATE"), Key("key"), Value("group"), Value("id"), Literal("MKSTREAM"))
+                  RespCommandArguments(Literal("CREATE"), Key("key"), Value("group"), Value("id"), Literal("MKSTREAM"))
                 )
               )
             )
@@ -1138,14 +1138,14 @@ object InputSpec extends BaseSpec {
         test("valid value") {
           ZIO
             .attempt(XGroupSetIdInput[String, String, String]().encode(XGroupCommand.SetId("key", "group", "id")))
-            .map(assert(_)(equalTo(RespCommand(Literal("SETID"), Key("key"), Value("group"), Value("id")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("SETID"), Key("key"), Value("group"), Value("id")))))
         }
       ),
       suite("XGroupDestroy")(
         test("valid value") {
           ZIO
             .attempt(XGroupDestroyInput[String, String]().encode(XGroupCommand.Destroy("key", "group")))
-            .map(assert(_)(equalTo(RespCommand(Literal("DESTROY"), Key("key"), Value("group")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("DESTROY"), Key("key"), Value("group")))))
         }
       ),
       suite("XGroupCreateConsumer")(
@@ -1158,7 +1158,7 @@ object InputSpec extends BaseSpec {
             )
             .map(
               assert(_)(
-                equalTo(RespCommand(Literal("CREATECONSUMER"), Key("key"), Value("group"), Value("consumer")))
+                equalTo(RespCommandArguments(Literal("CREATECONSUMER"), Key("key"), Value("group"), Value("consumer")))
               )
             )
         }
@@ -1172,7 +1172,7 @@ object InputSpec extends BaseSpec {
               )
             )
             .map(
-              assert(_)(equalTo(RespCommand(Literal("DELCONSUMER"), Key("key"), Value("group"), Value("consumer"))))
+              assert(_)(equalTo(RespCommandArguments(Literal("DELCONSUMER"), Key("key"), Value("group"), Value("consumer"))))
             )
         }
       ),
@@ -1180,80 +1180,80 @@ object InputSpec extends BaseSpec {
         test("with 1 second") {
           ZIO
             .attempt(BlockInput.encode(1.second))
-            .map(assert(_)(equalTo(RespCommand(Literal("BLOCK"), Value("1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("BLOCK"), Value("1000")))))
         },
         test("with 100 milliseconds") {
           ZIO
             .attempt(BlockInput.encode(100.millis))
-            .map(assert(_)(equalTo(RespCommand(Literal("BLOCK"), Value("100")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("BLOCK"), Value("100")))))
         },
         test("with negative duration") {
           ZIO
             .attempt(BlockInput.encode((-1).second))
-            .map(assert(_)(equalTo(RespCommand(Literal("BLOCK"), Value("-1000")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("BLOCK"), Value("-1000")))))
         }
       ),
       suite("Streams")(
         test("with one pair") {
           ZIO
             .attempt(StreamsInput[String, String]().encode(("a" -> "b", Chunk.empty)))
-            .map(assert(_)(equalTo(RespCommand(Literal("STREAMS"), Key("a"), Value("b")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("STREAMS"), Key("a"), Value("b")))))
         },
         test("with multiple pairs") {
           ZIO
             .attempt(StreamsInput[String, String]().encode(("a" -> "b", Chunk.single("c" -> "d"))))
-            .map(assert(_)(equalTo(RespCommand(Literal("STREAMS"), Key("a"), Key("c"), Value("b"), Value("d")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("STREAMS"), Key("a"), Key("c"), Value("b"), Value("d")))))
         }
       ),
       suite("NoAck")(
         test("valid value") {
-          ZIO.attempt(NoAckInput.encode(NoAck)).map(assert(_)(equalTo(RespCommand(Value("NOACK")))))
+          ZIO.attempt(NoAckInput.encode(NoAck)).map(assert(_)(equalTo(RespCommandArguments(Value("NOACK")))))
         }
       ),
       suite("MaxLen")(
         test("with approximate") {
           ZIO
             .attempt(StreamMaxLenInput.encode(StreamMaxLen(approximate = true, 10)))
-            .map(assert(_)(equalTo(RespCommand(Literal("MAXLEN"), Literal("~"), Value("10")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("MAXLEN"), Literal("~"), Value("10")))))
         },
         test("without approximate") {
           ZIO
             .attempt(StreamMaxLenInput.encode(StreamMaxLen(approximate = false, 10)))
-            .map(assert(_)(equalTo(RespCommand(Literal("MAXLEN"), Value("10")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("MAXLEN"), Value("10")))))
         }
       ),
       suite("WithForce")(
         test("valid value") {
-          ZIO.attempt(WithForceInput.encode(WithForce)).map(assert(_)(equalTo(RespCommand(Literal("FORCE")))))
+          ZIO.attempt(WithForceInput.encode(WithForce)).map(assert(_)(equalTo(RespCommandArguments(Literal("FORCE")))))
         }
       ),
       suite("WithJustId")(
         test("valid value") {
-          ZIO.attempt(WithJustIdInput.encode(WithJustId)).map(assert(_)(equalTo(RespCommand(Literal("JUSTID")))))
+          ZIO.attempt(WithJustIdInput.encode(WithJustId)).map(assert(_)(equalTo(RespCommandArguments(Literal("JUSTID")))))
         }
       ),
       suite("Side")(
         test("left") {
           for {
             result <- ZIO.attempt(SideInput.encode(Side.Left))
-          } yield assert(result)(equalTo(RespCommand(Literal("LEFT"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("LEFT"))))
         },
         test("right") {
           for {
             result <- ZIO.attempt(SideInput.encode(Side.Right))
-          } yield assert(result)(equalTo(RespCommand(Literal("RIGHT"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Literal("RIGHT"))))
         }
       ),
       suite("ListMaxLen")(
         test("valid value") {
           ZIO
             .attempt(ListMaxLenInput.encode(ListMaxLen(10L)))
-            .map(assert(_)(equalTo(RespCommand(Literal("MAXLEN"), Value("10")))))
+            .map(assert(_)(equalTo(RespCommandArguments(Literal("MAXLEN"), Value("10")))))
         }
       ),
       suite("Rank")(
         test("valid value") {
-          ZIO.attempt(RankInput.encode(Rank(10L))).map(assert(_)(equalTo(RespCommand(Literal("RANK"), Value("10")))))
+          ZIO.attempt(RankInput.encode(Rank(10L))).map(assert(_)(equalTo(RespCommandArguments(Literal("RANK"), Value("10")))))
         }
       ),
       suite("GetEx")(
@@ -1263,10 +1263,10 @@ object InputSpec extends BaseSpec {
               ZIO.attempt(GetExInput[String]().encode(scala.Tuple3.apply("key", Expire.SetExpireSeconds, 1.second)))
             resultMilliseconds <-
               ZIO.attempt(GetExInput[String]().encode(scala.Tuple3("key", Expire.SetExpireMilliseconds, 100.millis)))
-          } yield assert(resultSeconds)(equalTo(RespCommand(Key("key"), Literal("EX"), Value("1")))) && assert(
+          } yield assert(resultSeconds)(equalTo(RespCommandArguments(Key("key"), Literal("EX"), Value("1")))) && assert(
             resultMilliseconds
           )(
-            equalTo(RespCommand(Key("key"), Literal("PX"), Value("100")))
+            equalTo(RespCommandArguments(Key("key"), Literal("PX"), Value("100")))
           )
         },
         test("GetExAtInput - valid value") {
@@ -1284,17 +1284,17 @@ object InputSpec extends BaseSpec {
                 )
               )
           } yield assert(resultSeconds)(
-            equalTo(RespCommand(Key("key"), Literal("EXAT"), Value("1617667200")))
+            equalTo(RespCommandArguments(Key("key"), Literal("EXAT"), Value("1617667200")))
           ) && assert(resultMilliseconds)(
-            equalTo(RespCommand(Key("key"), Literal("PXAT"), Value("1617667200000")))
+            equalTo(RespCommandArguments(Key("key"), Literal("PXAT"), Value("1617667200000")))
           )
         },
         test("GetExPersistInput - valid value") {
           for {
             result              <- ZIO.attempt(GetExPersistInput[String]().encode("key" -> true))
             resultWithoutOption <- ZIO.attempt(GetExPersistInput[String]().encode("key" -> false))
-          } yield assert(result)(equalTo(RespCommand(Key("key"), Literal("PERSIST")))) &&
-            assert(resultWithoutOption)(equalTo(RespCommand(Key("key"))))
+          } yield assert(result)(equalTo(RespCommandArguments(Key("key"), Literal("PERSIST")))) &&
+            assert(resultWithoutOption)(equalTo(RespCommandArguments(Key("key"))))
         }
       )
     )