diff --git a/cmd/x32-cli/bus.go b/cmd/x32-cli/bus.go
index 896a15b..0b06074 100644
--- a/cmd/x32-cli/bus.go
+++ b/cmd/x32-cli/bus.go
@@ -172,7 +172,7 @@ type BusEqCmdGroup struct {
 	On   BusEqOnCmd   `help:"Get or set the EQ on/off state of the bus."              cmd:"on"`
 	Mode BusEqModeCmd `help:"Get or set the EQ mode of the bus (peq, geq or teq)."    cmd:"mode"`
 	Band struct {
-		Band int              `arg:"" help:"The EQ band number."`
+		Band *int             `arg:"" help:"The EQ band number." optional:""`
 		Gain BusEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:"gain"`
 		Freq BusEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:"freq"`
 		Q    BusEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:"q"`
@@ -182,12 +182,12 @@ type BusEqCmdGroup struct {
 
 // Validate checks that the provided EQ band number is within the valid range (1-6).
 func (cmd *BusEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -246,18 +246,18 @@ type BusEqBandGainCmd struct {
 // Run executes the BusEqBandGainCmd command, either retrieving the current gain of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, busEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, *busEq.Band.Band, *cmd.Gain); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, busEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -269,18 +269,18 @@ type BusEqBandFreqCmd struct {
 // Run executes the BusEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, busEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, *cmd.Freq)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
 	return nil
 }
 
@@ -292,18 +292,18 @@ type BusEqBandQCmd struct {
 // Run executes the BusEqBandQCmd command, either retrieving the current Q factor of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, busEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, *busEq.Band.Band, *cmd.Q); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, busEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -315,18 +315,18 @@ type BusEqBandTypeCmd struct {
 // Run executes the BusEqBandTypeCmd command, either retrieving the current type of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, busEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, *busEq.Band.Band, *cmd.Type); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, busEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/x32-cli/main.go b/cmd/x32-cli/main.go
index fc6a37a..46b74b2 100644
--- a/cmd/x32-cli/main.go
+++ b/cmd/x32-cli/main.go
@@ -135,7 +135,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
-		Band int               `arg:"" help:"The EQ band number."`
+		Band *int              `arg:"" help:"The EQ band number." optional:""`
 		Gain MainEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -145,12 +145,12 @@ type MainEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main L/R output.
 func (cmd *MainEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -186,18 +186,18 @@ type MainEqBandGainCmd struct {
 // Run executes the MainEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Main.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -209,18 +209,18 @@ type MainEqBandFreqCmd struct {
 // Run executes the MainEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Main.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -232,18 +232,18 @@ type MainEqBandQCmd struct {
 // Run executes the MainEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Main.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -255,18 +255,18 @@ type MainEqBandTypeCmd struct {
 // Run executes the MainEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Main.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/x32-cli/mainmono.go b/cmd/x32-cli/mainmono.go
index ccb30f5..4fa665b 100644
--- a/cmd/x32-cli/mainmono.go
+++ b/cmd/x32-cli/mainmono.go
@@ -135,7 +135,7 @@ func (cmd *MainMonoFadeoutCmd) Run(ctx *context) error {
 type MainMonoEqCmdGroup struct {
 	On   MainMonoEqOnCmd `help:"Get or set the EQ on/off state of the Main Mono output."               cmd:"on"`
 	Band struct {
-		Band int                   `arg:"" help:"The EQ band number."`
+		Band *int                  `arg:"" help:"The EQ band number." optional:""`
 		Gain MainMonoEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainMonoEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainMonoEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -145,12 +145,12 @@ type MainMonoEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main Mono output.
 func (cmd *MainMonoEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -186,18 +186,18 @@ type MainMonoEqBandGainCmd struct {
 // Run executes the MainMonoEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.MainMono.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -209,18 +209,18 @@ type MainMonoEqBandFreqCmd struct {
 // Run executes the MainMonoEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.MainMono.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -232,18 +232,18 @@ type MainMonoEqBandQCmd struct {
 // Run executes the MainMonoEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.MainMono.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -255,18 +255,18 @@ type MainMonoEqBandTypeCmd struct {
 // Run executes the MainMonoEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.MainMono.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/x32-cli/matrix.go b/cmd/x32-cli/matrix.go
index 791a843..2333926 100644
--- a/cmd/x32-cli/matrix.go
+++ b/cmd/x32-cli/matrix.go
@@ -145,7 +145,7 @@ func (cmd *MatrixFadeoutCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 type MatrixEqCmdGroup struct {
 	On   MatrixEqOnCmd `help:"Get or set the EQ on/off state of the Matrix output."               cmd:"on"`
 	Band struct {
-		Band int                 `arg:"" help:"The EQ band number."`
+		Band *int                `arg:"" help:"The EQ band number." optional:""`
 		Gain MatrixEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MatrixEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MatrixEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -155,12 +155,12 @@ type MatrixEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Matrix output.
 func (cmd *MatrixEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -196,18 +196,18 @@ type MatrixEqBandGainCmd struct {
 // Run executes the MatrixEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandGainCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Matrix.Eq.Gain(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Gain(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d gain: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d gain: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain: %.2f dB\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain: %.2f dB\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetGain(matrix.Index.Index, matrixEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d gain: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetGain(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d gain: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain set to: %.2f dB\n", matrixEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain set to: %.2f dB\n", *matrixEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -219,18 +219,18 @@ type MatrixEqBandFreqCmd struct {
 // Run executes the MatrixEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandFreqCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Matrix.Eq.Frequency(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Frequency(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d frequency: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d frequency: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency: %.2f Hz\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency: %.2f Hz\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetFrequency(matrix.Index.Index, matrixEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d frequency: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetFrequency(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d frequency: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency set to: %.2f Hz\n", matrixEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency set to: %.2f Hz\n", *matrixEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -242,18 +242,18 @@ type MatrixEqBandQCmd struct {
 // Run executes the MatrixEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandQCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Matrix.Eq.Q(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Q(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d Q factor: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d Q factor: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor: %.2f\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor: %.2f\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetQ(matrix.Index.Index, matrixEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d Q factor: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetQ(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d Q factor: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor set to: %.2f\n", matrixEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor set to: %.2f\n", *matrixEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -265,18 +265,18 @@ type MatrixEqBandTypeCmd struct {
 // Run executes the MatrixEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandTypeCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Matrix.Eq.Type(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Type(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d type: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d type: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d type: %s\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d type: %s\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetType(matrix.Index.Index, matrixEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d type: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetType(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d type: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d type set to: %s\n", matrixEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d type set to: %s\n", *matrixEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/x32-cli/snapshot.go b/cmd/x32-cli/snapshot.go
index e047637..6ed193f 100644
--- a/cmd/x32-cli/snapshot.go
+++ b/cmd/x32-cli/snapshot.go
@@ -5,7 +5,7 @@ import "fmt"
 type SnapshotCmdGroup struct {
 	List  ListCmd `help:"List all snapshots."        cmd:"list"`
 	Index struct {
-		Index  int       `arg:"" help:"The index of the snapshot."`
+		Index  *int      `arg:"" help:"The index of the snapshot." optional:""`
 		Name   NameCmd   `help:"Get or set the name of a snapshot."      cmd:"name"`
 		Save   SaveCmd   `help:"Save the current mixer state to a snapshot." cmd:"save"`
 		Load   LoadCmd   `help:"Load a mixer state from a snapshot."         cmd:"load"`
@@ -13,6 +13,19 @@ type SnapshotCmdGroup struct {
 	} `help:"The index of the snapshot."            arg:""`
 }
 
+// Validate checks if the provided snapshot index is within the valid range (1-64) when any of the subcommands that require an index are used.
+func (c *SnapshotCmdGroup) Validate() error {
+	if c.Index.Index == nil {
+		return nil
+	}
+
+	if *c.Index.Index < 1 || *c.Index.Index > 64 {
+		return fmt.Errorf("snapshot index must be between 1 and 64")
+	}
+
+	return nil
+}
+
 type ListCmd struct {
 }
 
@@ -36,7 +49,7 @@ type NameCmd struct {
 
 func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	if c.Name == nil {
-		name, err := ctx.Client.Snapshot.Name(snapshot.Index.Index)
+		name, err := ctx.Client.Snapshot.Name(*snapshot.Index.Index)
 		if err != nil {
 			return err
 		}
@@ -44,7 +57,7 @@ func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return nil
 	}
 
-	return ctx.Client.Snapshot.SetName(snapshot.Index.Index, *c.Name)
+	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *c.Name)
 }
 
 type SaveCmd struct {
@@ -57,19 +70,19 @@ func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return err
 	}
 
-	return ctx.Client.Snapshot.CurrentSave(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
 type LoadCmd struct {
 }
 
 func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentLoad(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
 type DeleteCmd struct {
 }
 
 func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentDelete(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)
 }
diff --git a/cmd/x32-cli/strip.go b/cmd/x32-cli/strip.go
index fe0ac52..19ab1e4 100644
--- a/cmd/x32-cli/strip.go
+++ b/cmd/x32-cli/strip.go
@@ -363,7 +363,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 type StripEqCmdGroup struct {
 	On   StripEqOnCmd `help:"Get or set the EQ on/off state of the strip."              cmd:""`
 	Band struct {
-		Band int                `arg:"" help:"The EQ band number."`
+		Band *int               `arg:"" help:"The EQ band number." optional:""`
 		Gain StripEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:""`
 		Freq StripEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:""`
 		Q    StripEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:""`
@@ -373,12 +373,12 @@ type StripEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is valid (between 1 and 4) and returns an error if it is not.
 func (cmd *StripEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 4 {
-		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 4 {
+		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -414,18 +414,18 @@ type StripEqBandGainCmd struct {
 // Run executes the StripEqBandGainCmd command, either retrieving the current gain of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band gain: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, stripEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -437,22 +437,22 @@ type StripEqBandFreqCmd struct {
 // Run executes the StripEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band frequency: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, stripEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
 		ctx.Out,
 		"Strip %d EQ band %d frequency set to: %.2f Hz\n",
 		strip.Index.Index,
-		stripEq.Band.Band,
+		*stripEq.Band.Band,
 		*cmd.Freq,
 	)
 	return nil
@@ -466,18 +466,18 @@ type StripEqBandQCmd struct {
 // Run executes the StripEqBandQCmd command, either retrieving the current Q factor of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band Q factor: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, stripEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, *stripEq.Band.Band, *cmd.Q); err != nil {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -489,18 +489,18 @@ type StripEqBandTypeCmd struct {
 // Run executes the StripEqBandTypeCmd command, either retrieving the current type of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band type: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, stripEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, stripEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/xair-cli/bus.go b/cmd/xair-cli/bus.go
index 887ed5b..05352ab 100644
--- a/cmd/xair-cli/bus.go
+++ b/cmd/xair-cli/bus.go
@@ -172,7 +172,7 @@ type BusEqCmdGroup struct {
 	On   BusEqOnCmd   `help:"Get or set the EQ on/off state of the bus."              cmd:"on"`
 	Mode BusEqModeCmd `help:"Get or set the EQ mode of the bus (peq, geq or teq)."    cmd:"mode"`
 	Band struct {
-		Band int              `arg:"" help:"The EQ band number."`
+		Band *int             `arg:"" help:"The EQ band number." optional:""`
 		Gain BusEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:"gain"`
 		Freq BusEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:"freq"`
 		Q    BusEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:"q"`
@@ -181,14 +181,13 @@ type BusEqCmdGroup struct {
 }
 
 // Validate checks that the provided EQ band number is within the valid range (1-6).
-// Only validates when a band number is actually specified (non-zero).
 func (cmd *BusEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -247,7 +246,7 @@ type BusEqBandGainCmd struct {
 // Run executes the BusEqBandGainCmd command, either retrieving the current gain of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
@@ -255,10 +254,10 @@ func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, busEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, *busEq.Band.Band, *cmd.Gain); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, busEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -270,18 +269,18 @@ type BusEqBandFreqCmd struct {
 // Run executes the BusEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, busEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, *cmd.Freq)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
 	return nil
 }
 
@@ -293,18 +292,18 @@ type BusEqBandQCmd struct {
 // Run executes the BusEqBandQCmd command, either retrieving the current Q factor of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, busEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, *busEq.Band.Band, *cmd.Q); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, busEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -316,18 +315,18 @@ type BusEqBandTypeCmd struct {
 // Run executes the BusEqBandTypeCmd command, either retrieving the current type of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, busEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, *busEq.Band.Band, *cmd.Type); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, busEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/xair-cli/main.go b/cmd/xair-cli/main.go
index fc6a37a..46b74b2 100644
--- a/cmd/xair-cli/main.go
+++ b/cmd/xair-cli/main.go
@@ -135,7 +135,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
-		Band int               `arg:"" help:"The EQ band number."`
+		Band *int              `arg:"" help:"The EQ band number." optional:""`
 		Gain MainEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -145,12 +145,12 @@ type MainEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main L/R output.
 func (cmd *MainEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -186,18 +186,18 @@ type MainEqBandGainCmd struct {
 // Run executes the MainEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Main.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -209,18 +209,18 @@ type MainEqBandFreqCmd struct {
 // Run executes the MainEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Main.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -232,18 +232,18 @@ type MainEqBandQCmd struct {
 // Run executes the MainEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Main.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -255,18 +255,18 @@ type MainEqBandTypeCmd struct {
 // Run executes the MainEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Main.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 
diff --git a/cmd/xair-cli/snapshot.go b/cmd/xair-cli/snapshot.go
index e047637..6ed193f 100644
--- a/cmd/xair-cli/snapshot.go
+++ b/cmd/xair-cli/snapshot.go
@@ -5,7 +5,7 @@ import "fmt"
 type SnapshotCmdGroup struct {
 	List  ListCmd `help:"List all snapshots."        cmd:"list"`
 	Index struct {
-		Index  int       `arg:"" help:"The index of the snapshot."`
+		Index  *int      `arg:"" help:"The index of the snapshot." optional:""`
 		Name   NameCmd   `help:"Get or set the name of a snapshot."      cmd:"name"`
 		Save   SaveCmd   `help:"Save the current mixer state to a snapshot." cmd:"save"`
 		Load   LoadCmd   `help:"Load a mixer state from a snapshot."         cmd:"load"`
@@ -13,6 +13,19 @@ type SnapshotCmdGroup struct {
 	} `help:"The index of the snapshot."            arg:""`
 }
 
+// Validate checks if the provided snapshot index is within the valid range (1-64) when any of the subcommands that require an index are used.
+func (c *SnapshotCmdGroup) Validate() error {
+	if c.Index.Index == nil {
+		return nil
+	}
+
+	if *c.Index.Index < 1 || *c.Index.Index > 64 {
+		return fmt.Errorf("snapshot index must be between 1 and 64")
+	}
+
+	return nil
+}
+
 type ListCmd struct {
 }
 
@@ -36,7 +49,7 @@ type NameCmd struct {
 
 func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	if c.Name == nil {
-		name, err := ctx.Client.Snapshot.Name(snapshot.Index.Index)
+		name, err := ctx.Client.Snapshot.Name(*snapshot.Index.Index)
 		if err != nil {
 			return err
 		}
@@ -44,7 +57,7 @@ func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return nil
 	}
 
-	return ctx.Client.Snapshot.SetName(snapshot.Index.Index, *c.Name)
+	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *c.Name)
 }
 
 type SaveCmd struct {
@@ -57,19 +70,19 @@ func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return err
 	}
 
-	return ctx.Client.Snapshot.CurrentSave(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
 type LoadCmd struct {
 }
 
 func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentLoad(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
 type DeleteCmd struct {
 }
 
 func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentDelete(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)
 }
diff --git a/cmd/xair-cli/strip.go b/cmd/xair-cli/strip.go
index fe0ac52..19ab1e4 100644
--- a/cmd/xair-cli/strip.go
+++ b/cmd/xair-cli/strip.go
@@ -363,7 +363,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 type StripEqCmdGroup struct {
 	On   StripEqOnCmd `help:"Get or set the EQ on/off state of the strip."              cmd:""`
 	Band struct {
-		Band int                `arg:"" help:"The EQ band number."`
+		Band *int               `arg:"" help:"The EQ band number." optional:""`
 		Gain StripEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:""`
 		Freq StripEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:""`
 		Q    StripEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:""`
@@ -373,12 +373,12 @@ type StripEqCmdGroup struct {
 
 // Validate checks if the provided EQ band number is valid (between 1 and 4) and returns an error if it is not.
 func (cmd *StripEqCmdGroup) Validate() error {
-	if cmd.Band.Band == 0 {
+	if cmd.Band.Band == nil {
 		return nil
 	}
 
-	if cmd.Band.Band < 1 || cmd.Band.Band > 4 {
-		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", cmd.Band.Band)
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 4 {
+		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -414,18 +414,18 @@ type StripEqBandGainCmd struct {
 // Run executes the StripEqBandGainCmd command, either retrieving the current gain of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band gain: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, stripEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -437,22 +437,22 @@ type StripEqBandFreqCmd struct {
 // Run executes the StripEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band frequency: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, stripEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
 		ctx.Out,
 		"Strip %d EQ band %d frequency set to: %.2f Hz\n",
 		strip.Index.Index,
-		stripEq.Band.Band,
+		*stripEq.Band.Band,
 		*cmd.Freq,
 	)
 	return nil
@@ -466,18 +466,18 @@ type StripEqBandQCmd struct {
 // Run executes the StripEqBandQCmd command, either retrieving the current Q factor of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band Q factor: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, stripEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, *stripEq.Band.Band, *cmd.Q); err != nil {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -489,18 +489,18 @@ type StripEqBandTypeCmd struct {
 // Run executes the StripEqBandTypeCmd command, either retrieving the current type of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band type: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, stripEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, stripEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
 	return nil
 }