diff --git a/generated/nidaqmx/nidaqmx.proto b/generated/nidaqmx/nidaqmx.proto
index 53f244e73..abfc5f4f3 100644
--- a/generated/nidaqmx/nidaqmx.proto
+++ b/generated/nidaqmx/nidaqmx.proto
@@ -289,12 +289,19 @@ service NiDAQmx {
   rpc ReadCounterU32Ex(ReadCounterU32ExRequest) returns (ReadCounterU32ExResponse);
   rpc BeginReadCounterU32Ex(BeginReadCounterU32ExRequest) returns (BeginReadCounterU32ExResponse);
   rpc ReadCtrFreq(ReadCtrFreqRequest) returns (ReadCtrFreqResponse);
+  rpc BeginReadCtrFreq(BeginReadCtrFreqRequest) returns (BeginReadCtrFreqResponse);
   rpc ReadCtrFreqScalar(ReadCtrFreqScalarRequest) returns (ReadCtrFreqScalarResponse);
+  rpc BeginReadCtrFreqScalar(BeginReadCtrFreqScalarRequest) returns (BeginReadCtrFreqScalarResponse);
   rpc ReadCtrTicks(ReadCtrTicksRequest) returns (ReadCtrTicksResponse);
+  rpc BeginReadCtrTicks(BeginReadCtrTicksRequest) returns (BeginReadCtrTicksResponse);
   rpc ReadCtrTicksScalar(ReadCtrTicksScalarRequest) returns (ReadCtrTicksScalarResponse);
+  rpc BeginReadCtrTicksScalar(BeginReadCtrTicksScalarRequest) returns (BeginReadCtrTicksScalarResponse);
   rpc ReadCtrTime(ReadCtrTimeRequest) returns (ReadCtrTimeResponse);
+  rpc BeginReadCtrTime(BeginReadCtrTimeRequest) returns (BeginReadCtrTimeResponse);
   rpc ReadCtrTimeScalar(ReadCtrTimeScalarRequest) returns (ReadCtrTimeScalarResponse);
+  rpc BeginReadCtrTimeScalar(BeginReadCtrTimeScalarRequest) returns (BeginReadCtrTimeScalarResponse);
   rpc ReadDigitalLines(ReadDigitalLinesRequest) returns (ReadDigitalLinesResponse);
+  rpc BeginReadDigitalLines(BeginReadDigitalLinesRequest) returns (BeginReadDigitalLinesResponse);
   rpc ReadDigitalScalarU32(ReadDigitalScalarU32Request) returns (ReadDigitalScalarU32Response);
   rpc BeginReadDigitalScalarU32(BeginReadDigitalScalarU32Request) returns (BeginReadDigitalScalarU32Response);
   rpc ReadDigitalU16(ReadDigitalU16Request) returns (ReadDigitalU16Response);
@@ -302,10 +309,15 @@ service NiDAQmx {
   rpc ReadDigitalU32(ReadDigitalU32Request) returns (ReadDigitalU32Response);
   rpc BeginReadDigitalU32(BeginReadDigitalU32Request) returns (BeginReadDigitalU32Response);
   rpc ReadDigitalU8(ReadDigitalU8Request) returns (ReadDigitalU8Response);
+  rpc BeginReadDigitalU8(BeginReadDigitalU8Request) returns (BeginReadDigitalU8Response);
   rpc ReadPowerBinaryI16(ReadPowerBinaryI16Request) returns (ReadPowerBinaryI16Response);
+  rpc BeginReadPowerBinaryI16(BeginReadPowerBinaryI16Request) returns (BeginReadPowerBinaryI16Response);
   rpc ReadPowerF64(ReadPowerF64Request) returns (ReadPowerF64Response);
+  rpc BeginReadPowerF64(BeginReadPowerF64Request) returns (BeginReadPowerF64Response);
   rpc ReadPowerScalarF64(ReadPowerScalarF64Request) returns (ReadPowerScalarF64Response);
+  rpc BeginReadPowerScalarF64(BeginReadPowerScalarF64Request) returns (BeginReadPowerScalarF64Response);
   rpc ReadRaw(ReadRawRequest) returns (ReadRawResponse);
+  rpc BeginReadRaw(BeginReadRawRequest) returns (BeginReadRawResponse);
   rpc RegisterDoneEvent(RegisterDoneEventRequest) returns (stream RegisterDoneEventResponse);
   rpc RegisterEveryNSamplesEvent(RegisterEveryNSamplesEventRequest) returns (stream RegisterEveryNSamplesEventResponse);
   rpc RegisterSignalEvent(RegisterSignalEventRequest) returns (stream RegisterSignalEventResponse);
@@ -8518,7 +8530,7 @@ message BeginReadAnalogF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadAnalogF64StreamingResponse {
+message MonikerReadAnalogF64Response {
   int32 status = 1;
   repeated double read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8544,7 +8556,7 @@ message BeginReadAnalogScalarF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadAnalogScalarF64StreamingResponse {
+message MonikerReadAnalogScalarF64Response {
   int32 status = 1;
   double value = 2;
 }
@@ -8582,7 +8594,7 @@ message BeginReadBinaryI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadBinaryI16StreamingResponse {
+message MonikerReadBinaryI16Response {
   int32 status = 1;
   repeated int32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8621,7 +8633,7 @@ message BeginReadBinaryI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadBinaryI32StreamingResponse {
+message MonikerReadBinaryI32Response {
   int32 status = 1;
   repeated int32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8660,7 +8672,7 @@ message BeginReadBinaryU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadBinaryU16StreamingResponse {
+message MonikerReadBinaryU16Response {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8699,7 +8711,7 @@ message BeginReadBinaryU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadBinaryU32StreamingResponse {
+message MonikerReadBinaryU32Response {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8730,7 +8742,7 @@ message BeginReadCounterF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterF64StreamingResponse {
+message MonikerReadCounterF64Response {
   int32 status = 1;
   repeated double read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8769,7 +8781,7 @@ message BeginReadCounterF64ExResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterF64ExStreamingResponse {
+message MonikerReadCounterF64ExResponse {
   int32 status = 1;
   repeated double read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8795,7 +8807,7 @@ message BeginReadCounterScalarF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterScalarF64StreamingResponse {
+message MonikerReadCounterScalarF64Response {
   int32 status = 1;
   double value = 2;
 }
@@ -8820,7 +8832,7 @@ message BeginReadCounterScalarU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterScalarU32StreamingResponse {
+message MonikerReadCounterScalarU32Response {
   int32 status = 1;
   uint32 value = 2;
 }
@@ -8850,7 +8862,7 @@ message BeginReadCounterU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterU32StreamingResponse {
+message MonikerReadCounterU32Response {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8889,7 +8901,7 @@ message BeginReadCounterU32ExResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadCounterU32ExStreamingResponse {
+message MonikerReadCounterU32ExResponse {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -8913,6 +8925,29 @@ message ReadCtrFreqResponse {
   int32 samps_per_chan_read = 4;
 }
 
+message BeginReadCtrFreqRequest {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof interleaved_enum {
+    GroupBy interleaved = 4;
+    int32 interleaved_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadCtrFreqResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrFreqResponse {
+  int32 status = 1;
+  repeated double read_array_frequency = 2;
+  repeated double read_array_duty_cycle = 3;
+  int32 samps_per_chan_read = 4;
+}
+
 message ReadCtrFreqScalarRequest {
   nidevice_grpc.Session task = 1;
   double timeout = 2;
@@ -8924,6 +8959,22 @@ message ReadCtrFreqScalarResponse {
   double duty_cycle = 3;
 }
 
+message BeginReadCtrFreqScalarRequest {
+  nidevice_grpc.Session task = 1;
+  double timeout = 2;
+}
+
+message BeginReadCtrFreqScalarResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrFreqScalarResponse {
+  int32 status = 1;
+  double frequency = 2;
+  double duty_cycle = 3;
+}
+
 message ReadCtrTicksRequest {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -8942,6 +8993,29 @@ message ReadCtrTicksResponse {
   int32 samps_per_chan_read = 4;
 }
 
+message BeginReadCtrTicksRequest {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof interleaved_enum {
+    GroupBy interleaved = 4;
+    int32 interleaved_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadCtrTicksResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrTicksResponse {
+  int32 status = 1;
+  repeated uint32 read_array_high_ticks = 2;
+  repeated uint32 read_array_low_ticks = 3;
+  int32 samps_per_chan_read = 4;
+}
+
 message ReadCtrTicksScalarRequest {
   nidevice_grpc.Session task = 1;
   double timeout = 2;
@@ -8953,6 +9027,22 @@ message ReadCtrTicksScalarResponse {
   uint32 low_ticks = 3;
 }
 
+message BeginReadCtrTicksScalarRequest {
+  nidevice_grpc.Session task = 1;
+  double timeout = 2;
+}
+
+message BeginReadCtrTicksScalarResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrTicksScalarResponse {
+  int32 status = 1;
+  uint32 high_ticks = 2;
+  uint32 low_ticks = 3;
+}
+
 message ReadCtrTimeRequest {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -8971,6 +9061,29 @@ message ReadCtrTimeResponse {
   int32 samps_per_chan_read = 4;
 }
 
+message BeginReadCtrTimeRequest {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof interleaved_enum {
+    GroupBy interleaved = 4;
+    int32 interleaved_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadCtrTimeResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrTimeResponse {
+  int32 status = 1;
+  repeated double read_array_high_time = 2;
+  repeated double read_array_low_time = 3;
+  int32 samps_per_chan_read = 4;
+}
+
 message ReadCtrTimeScalarRequest {
   nidevice_grpc.Session task = 1;
   double timeout = 2;
@@ -8982,6 +9095,22 @@ message ReadCtrTimeScalarResponse {
   double low_time = 3;
 }
 
+message BeginReadCtrTimeScalarRequest {
+  nidevice_grpc.Session task = 1;
+  double timeout = 2;
+}
+
+message BeginReadCtrTimeScalarResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadCtrTimeScalarResponse {
+  int32 status = 1;
+  double high_time = 2;
+  double low_time = 3;
+}
+
 message ReadDigitalLinesRequest {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -9000,6 +9129,30 @@ message ReadDigitalLinesResponse {
   int32 num_bytes_per_samp = 4;
 }
 
+message BeginReadDigitalLinesRequest {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof fill_mode_enum {
+    GroupBy fill_mode = 4;
+    int32 fill_mode_raw = 5;
+  }
+  uint32 array_size_in_bytes = 6;
+}
+
+message BeginReadDigitalLinesResponse {
+  int32 status = 1;
+  int32 num_bytes_per_samp = 2;
+  ni.data_monikers.Moniker moniker = 3;
+}
+
+message MonikerReadDigitalLinesResponse {
+  int32 status = 1;
+  bytes read_array = 2;
+  int32 samps_per_chan_read = 3;
+  int32 num_bytes_per_samp = 4;
+}
+
 message ReadDigitalScalarU32Request {
   nidevice_grpc.Session task = 1;
   double timeout = 2;
@@ -9020,7 +9173,7 @@ message BeginReadDigitalScalarU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadDigitalScalarU32StreamingResponse {
+message MonikerReadDigitalScalarU32Response {
   int32 status = 1;
   uint32 value = 2;
 }
@@ -9058,7 +9211,7 @@ message BeginReadDigitalU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadDigitalU16StreamingResponse {
+message MonikerReadDigitalU16Response {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -9097,7 +9250,7 @@ message BeginReadDigitalU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadDigitalU32StreamingResponse {
+message MonikerReadDigitalU32Response {
   int32 status = 1;
   repeated uint32 read_array = 2;
   int32 samps_per_chan_read = 3;
@@ -9120,6 +9273,28 @@ message ReadDigitalU8Response {
   int32 samps_per_chan_read = 3;
 }
 
+message BeginReadDigitalU8Request {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof fill_mode_enum {
+    GroupBy fill_mode = 4;
+    int32 fill_mode_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadDigitalU8Response {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadDigitalU8Response {
+  int32 status = 1;
+  bytes read_array = 2;
+  int32 samps_per_chan_read = 3;
+}
+
 message ReadPowerBinaryI16Request {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -9138,6 +9313,29 @@ message ReadPowerBinaryI16Response {
   int32 samps_per_chan_read = 4;
 }
 
+message BeginReadPowerBinaryI16Request {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof fill_mode_enum {
+    GroupBy fill_mode = 4;
+    int32 fill_mode_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadPowerBinaryI16Response {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadPowerBinaryI16Response {
+  int32 status = 1;
+  repeated int32 read_array_voltage = 2;
+  repeated int32 read_array_current = 3;
+  int32 samps_per_chan_read = 4;
+}
+
 message ReadPowerF64Request {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -9156,6 +9354,29 @@ message ReadPowerF64Response {
   int32 samps_per_chan_read = 4;
 }
 
+message BeginReadPowerF64Request {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  oneof fill_mode_enum {
+    GroupBy fill_mode = 4;
+    int32 fill_mode_raw = 5;
+  }
+  uint32 array_size_in_samps = 6;
+}
+
+message BeginReadPowerF64Response {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadPowerF64Response {
+  int32 status = 1;
+  repeated double read_array_voltage = 2;
+  repeated double read_array_current = 3;
+  int32 samps_per_chan_read = 4;
+}
+
 message ReadPowerScalarF64Request {
   nidevice_grpc.Session task = 1;
   double timeout = 2;
@@ -9167,6 +9388,22 @@ message ReadPowerScalarF64Response {
   double current = 3;
 }
 
+message BeginReadPowerScalarF64Request {
+  nidevice_grpc.Session task = 1;
+  double timeout = 2;
+}
+
+message BeginReadPowerScalarF64Response {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadPowerScalarF64Response {
+  int32 status = 1;
+  double voltage = 2;
+  double current = 3;
+}
+
 message ReadRawRequest {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -9181,6 +9418,25 @@ message ReadRawResponse {
   int32 num_bytes_per_samp = 4;
 }
 
+message BeginReadRawRequest {
+  nidevice_grpc.Session task = 1;
+  int32 num_samps_per_chan = 2;
+  double timeout = 3;
+  uint32 array_size_in_bytes = 4;
+}
+
+message BeginReadRawResponse {
+  int32 status = 1;
+  ni.data_monikers.Moniker moniker = 2;
+}
+
+message MonikerReadRawResponse {
+  int32 status = 1;
+  bytes read_array = 2;
+  int32 samps_read = 3;
+  int32 num_bytes_per_samp = 4;
+}
+
 message RegisterDoneEventRequest {
   nidevice_grpc.Session task = 1;
 }
@@ -10491,7 +10747,7 @@ message BeginWaitForNextSampleClockResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WaitForNextSampleClockStreamingResponse {
+message MonikerWaitForNextSampleClockResponse {
   int32 status = 1;
   bool is_late = 2;
 }
@@ -10552,11 +10808,11 @@ message BeginWriteAnalogF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteAnalogF64StreamingRequest {
+message MonikerWriteAnalogF64Request {
   repeated double write_array = 1;
 }
 
-message WriteAnalogF64StreamingResponse {
+message MonikerWriteAnalogF64Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10583,11 +10839,11 @@ message BeginWriteAnalogScalarF64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteAnalogScalarF64StreamingRequest {
+message MonikerWriteAnalogScalarF64Request {
   double value = 1;
 }
 
-message WriteAnalogScalarF64StreamingResponse {
+message MonikerWriteAnalogScalarF64Response {
   int32 status = 1;
 }
 
@@ -10624,11 +10880,11 @@ message BeginWriteBinaryI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteBinaryI16StreamingRequest {
+message MonikerWriteBinaryI16Request {
   repeated int32 write_array = 1;
 }
 
-message WriteBinaryI16StreamingResponse {
+message MonikerWriteBinaryI16Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10666,11 +10922,11 @@ message BeginWriteBinaryI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteBinaryI32StreamingRequest {
+message MonikerWriteBinaryI32Request {
   repeated int32 write_array = 1;
 }
 
-message WriteBinaryI32StreamingResponse {
+message MonikerWriteBinaryI32Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10708,11 +10964,11 @@ message BeginWriteBinaryU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteBinaryU16StreamingRequest {
+message MonikerWriteBinaryU16Request {
   repeated uint32 write_array = 1;
 }
 
-message WriteBinaryU16StreamingResponse {
+message MonikerWriteBinaryU16Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10750,11 +11006,11 @@ message BeginWriteBinaryU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteBinaryU32StreamingRequest {
+message MonikerWriteBinaryU32Request {
   repeated uint32 write_array = 1;
 }
 
-message WriteBinaryU32StreamingResponse {
+message MonikerWriteBinaryU32Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10888,11 +11144,11 @@ message BeginWriteDigitalScalarU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteDigitalScalarU32StreamingRequest {
+message MonikerWriteDigitalScalarU32Request {
   uint32 value = 1;
 }
 
-message WriteDigitalScalarU32StreamingResponse {
+message MonikerWriteDigitalScalarU32Response {
   int32 status = 1;
 }
 
@@ -10929,11 +11185,11 @@ message BeginWriteDigitalU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteDigitalU16StreamingRequest {
+message MonikerWriteDigitalU16Request {
   repeated uint32 write_array = 1;
 }
 
-message WriteDigitalU16StreamingResponse {
+message MonikerWriteDigitalU16Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
@@ -10971,11 +11227,11 @@ message BeginWriteDigitalU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteDigitalU32StreamingRequest {
+message MonikerWriteDigitalU32Request {
   repeated uint32 write_array = 1;
 }
 
-message WriteDigitalU32StreamingResponse {
+message MonikerWriteDigitalU32Response {
   int32 status = 1;
   int32 samps_per_chan_written = 2;
 }
diff --git a/generated/nidaqmx/nidaqmx_client.cpp b/generated/nidaqmx/nidaqmx_client.cpp
index e3aa0f60d..ac5dd5f34 100644
--- a/generated/nidaqmx/nidaqmx_client.cpp
+++ b/generated/nidaqmx/nidaqmx_client.cpp
@@ -8072,6 +8072,34 @@ read_ctr_freq(const StubPtr& stub, const nidevice_grpc::Session& task, const pb:
   return response;
 }
 
+BeginReadCtrFreqResponse
+begin_read_ctr_freq(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrFreqRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto interleaved_ptr = interleaved.get_if<GroupBy>();
+  const auto interleaved_raw_ptr = interleaved.get_if<pb::int32>();
+  if (interleaved_ptr) {
+    request.set_interleaved(*interleaved_ptr);
+  }
+  else if (interleaved_raw_ptr) {
+    request.set_interleaved_raw(*interleaved_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadCtrFreqResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrFreq(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadCtrFreqScalarResponse
 read_ctr_freq_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
 {
@@ -8090,6 +8118,24 @@ read_ctr_freq_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, co
   return response;
 }
 
+BeginReadCtrFreqScalarResponse
+begin_read_ctr_freq_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrFreqScalarRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_timeout(timeout);
+
+  auto response = BeginReadCtrFreqScalarResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrFreqScalar(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadCtrTicksResponse
 read_ctr_ticks(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps)
 {
@@ -8118,6 +8164,34 @@ read_ctr_ticks(const StubPtr& stub, const nidevice_grpc::Session& task, const pb
   return response;
 }
 
+BeginReadCtrTicksResponse
+begin_read_ctr_ticks(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrTicksRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto interleaved_ptr = interleaved.get_if<GroupBy>();
+  const auto interleaved_raw_ptr = interleaved.get_if<pb::int32>();
+  if (interleaved_ptr) {
+    request.set_interleaved(*interleaved_ptr);
+  }
+  else if (interleaved_raw_ptr) {
+    request.set_interleaved_raw(*interleaved_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadCtrTicksResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrTicks(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadCtrTicksScalarResponse
 read_ctr_ticks_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
 {
@@ -8136,6 +8210,24 @@ read_ctr_ticks_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, c
   return response;
 }
 
+BeginReadCtrTicksScalarResponse
+begin_read_ctr_ticks_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrTicksScalarRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_timeout(timeout);
+
+  auto response = BeginReadCtrTicksScalarResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrTicksScalar(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadCtrTimeResponse
 read_ctr_time(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps)
 {
@@ -8164,6 +8256,34 @@ read_ctr_time(const StubPtr& stub, const nidevice_grpc::Session& task, const pb:
   return response;
 }
 
+BeginReadCtrTimeResponse
+begin_read_ctr_time(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrTimeRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto interleaved_ptr = interleaved.get_if<GroupBy>();
+  const auto interleaved_raw_ptr = interleaved.get_if<pb::int32>();
+  if (interleaved_ptr) {
+    request.set_interleaved(*interleaved_ptr);
+  }
+  else if (interleaved_raw_ptr) {
+    request.set_interleaved_raw(*interleaved_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadCtrTimeResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrTime(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadCtrTimeScalarResponse
 read_ctr_time_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
 {
@@ -8182,6 +8302,24 @@ read_ctr_time_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, co
   return response;
 }
 
+BeginReadCtrTimeScalarResponse
+begin_read_ctr_time_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadCtrTimeScalarRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_timeout(timeout);
+
+  auto response = BeginReadCtrTimeScalarResponse{};
+
+  raise_if_error(
+      stub->BeginReadCtrTimeScalar(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadDigitalLinesResponse
 read_digital_lines(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_bytes)
 {
@@ -8210,6 +8348,34 @@ read_digital_lines(const StubPtr& stub, const nidevice_grpc::Session& task, cons
   return response;
 }
 
+BeginReadDigitalLinesResponse
+begin_read_digital_lines(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_bytes)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadDigitalLinesRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto fill_mode_ptr = fill_mode.get_if<GroupBy>();
+  const auto fill_mode_raw_ptr = fill_mode.get_if<pb::int32>();
+  if (fill_mode_ptr) {
+    request.set_fill_mode(*fill_mode_ptr);
+  }
+  else if (fill_mode_raw_ptr) {
+    request.set_fill_mode_raw(*fill_mode_raw_ptr);
+  }
+  request.set_array_size_in_bytes(array_size_in_bytes);
+
+  auto response = BeginReadDigitalLinesResponse{};
+
+  raise_if_error(
+      stub->BeginReadDigitalLines(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadDigitalScalarU32Response
 read_digital_scalar_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
 {
@@ -8386,6 +8552,34 @@ read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const p
   return response;
 }
 
+BeginReadDigitalU8Response
+begin_read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadDigitalU8Request{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto fill_mode_ptr = fill_mode.get_if<GroupBy>();
+  const auto fill_mode_raw_ptr = fill_mode.get_if<pb::int32>();
+  if (fill_mode_ptr) {
+    request.set_fill_mode(*fill_mode_ptr);
+  }
+  else if (fill_mode_raw_ptr) {
+    request.set_fill_mode_raw(*fill_mode_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadDigitalU8Response{};
+
+  raise_if_error(
+      stub->BeginReadDigitalU8(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadPowerBinaryI16Response
 read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
 {
@@ -8414,6 +8608,34 @@ read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, c
   return response;
 }
 
+BeginReadPowerBinaryI16Response
+begin_read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadPowerBinaryI16Request{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto fill_mode_ptr = fill_mode.get_if<GroupBy>();
+  const auto fill_mode_raw_ptr = fill_mode.get_if<pb::int32>();
+  if (fill_mode_ptr) {
+    request.set_fill_mode(*fill_mode_ptr);
+  }
+  else if (fill_mode_raw_ptr) {
+    request.set_fill_mode_raw(*fill_mode_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadPowerBinaryI16Response{};
+
+  raise_if_error(
+      stub->BeginReadPowerBinaryI16(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadPowerF64Response
 read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
 {
@@ -8442,6 +8664,34 @@ read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb
   return response;
 }
 
+BeginReadPowerF64Response
+begin_read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadPowerF64Request{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  const auto fill_mode_ptr = fill_mode.get_if<GroupBy>();
+  const auto fill_mode_raw_ptr = fill_mode.get_if<pb::int32>();
+  if (fill_mode_ptr) {
+    request.set_fill_mode(*fill_mode_ptr);
+  }
+  else if (fill_mode_raw_ptr) {
+    request.set_fill_mode_raw(*fill_mode_raw_ptr);
+  }
+  request.set_array_size_in_samps(array_size_in_samps);
+
+  auto response = BeginReadPowerF64Response{};
+
+  raise_if_error(
+      stub->BeginReadPowerF64(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadPowerScalarF64Response
 read_power_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
 {
@@ -8460,6 +8710,24 @@ read_power_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, c
   return response;
 }
 
+BeginReadPowerScalarF64Response
+begin_read_power_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadPowerScalarF64Request{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_timeout(timeout);
+
+  auto response = BeginReadPowerScalarF64Response{};
+
+  raise_if_error(
+      stub->BeginReadPowerScalarF64(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadRawResponse
 read_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const pb::uint32& array_size_in_bytes)
 {
@@ -8480,6 +8748,26 @@ read_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int3
   return response;
 }
 
+BeginReadRawResponse
+begin_read_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const pb::uint32& array_size_in_bytes)
+{
+  ::grpc::ClientContext context;
+
+  auto request = BeginReadRawRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_num_samps_per_chan(num_samps_per_chan);
+  request.set_timeout(timeout);
+  request.set_array_size_in_bytes(array_size_in_bytes);
+
+  auto response = BeginReadRawResponse{};
+
+  raise_if_error(
+      stub->BeginReadRaw(&context, request, &response),
+      context);
+
+  return response;
+}
+
 std::unique_ptr<grpc::ClientReader<RegisterDoneEventResponse>>
 register_done_event(const StubPtr& stub, ::grpc::ClientContext& context, const nidevice_grpc::Session& task)
 {
diff --git a/generated/nidaqmx/nidaqmx_client.h b/generated/nidaqmx/nidaqmx_client.h
index 3ecc1e4f4..ee3164265 100644
--- a/generated/nidaqmx/nidaqmx_client.h
+++ b/generated/nidaqmx/nidaqmx_client.h
@@ -292,12 +292,19 @@ BeginReadCounterU32Response begin_read_counter_u32(const StubPtr& stub, const ni
 ReadCounterU32ExResponse read_counter_u32_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 BeginReadCounterU32ExResponse begin_read_counter_u32_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadCtrFreqResponse read_ctr_freq(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
+BeginReadCtrFreqResponse begin_read_ctr_freq(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
 ReadCtrFreqScalarResponse read_ctr_freq_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
+BeginReadCtrFreqScalarResponse begin_read_ctr_freq_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadCtrTicksResponse read_ctr_ticks(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
+BeginReadCtrTicksResponse begin_read_ctr_ticks(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
 ReadCtrTicksScalarResponse read_ctr_ticks_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
+BeginReadCtrTicksScalarResponse begin_read_ctr_ticks_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadCtrTimeResponse read_ctr_time(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
+BeginReadCtrTimeResponse begin_read_ctr_time(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& interleaved, const pb::uint32& array_size_in_samps);
 ReadCtrTimeScalarResponse read_ctr_time_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
+BeginReadCtrTimeScalarResponse begin_read_ctr_time_scalar(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadDigitalLinesResponse read_digital_lines(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_bytes);
+BeginReadDigitalLinesResponse begin_read_digital_lines(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_bytes);
 ReadDigitalScalarU32Response read_digital_scalar_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 BeginReadDigitalScalarU32Response begin_read_digital_scalar_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadDigitalU16Response read_digital_u16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
@@ -305,10 +312,15 @@ BeginReadDigitalU16Response begin_read_digital_u16(const StubPtr& stub, const ni
 ReadDigitalU32Response read_digital_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 BeginReadDigitalU32Response begin_read_digital_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadDigitalU8Response read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
+BeginReadDigitalU8Response begin_read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadPowerBinaryI16Response read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
+BeginReadPowerBinaryI16Response begin_read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadPowerF64Response read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
+BeginReadPowerF64Response begin_read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadPowerScalarF64Response read_power_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
+BeginReadPowerScalarF64Response begin_read_power_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadRawResponse read_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const pb::uint32& array_size_in_bytes);
+BeginReadRawResponse begin_read_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const pb::uint32& array_size_in_bytes);
 std::unique_ptr<grpc::ClientReader<RegisterDoneEventResponse>> register_done_event(const StubPtr& stub, ::grpc::ClientContext& context, const nidevice_grpc::Session& task);
 std::unique_ptr<grpc::ClientReader<RegisterEveryNSamplesEventResponse>> register_every_n_samples_event(const StubPtr& stub, ::grpc::ClientContext& context, const nidevice_grpc::Session& task, const simple_variant<EveryNSamplesEventType, pb::int32>& every_n_samples_event_type, const pb::uint32& n_samples);
 std::unique_ptr<grpc::ClientReader<RegisterSignalEventResponse>> register_signal_event(const StubPtr& stub, ::grpc::ClientContext& context, const nidevice_grpc::Session& task, const simple_variant<Signal2, pb::int32>& signal_id);
diff --git a/generated/nidaqmx/nidaqmx_service.cpp b/generated/nidaqmx/nidaqmx_service.cpp
index fc96c1d36..856dc772e 100644
--- a/generated/nidaqmx/nidaqmx_service.cpp
+++ b/generated/nidaqmx/nidaqmx_service.cpp
@@ -33,7 +33,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadAnalogF64StreamingResponse response;
+     nidaqmx_grpc::MonikerReadAnalogF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -42,7 +42,7 @@ namespace nidaqmx_grpc {
      TaskHandle task;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::ReadAnalogScalarF64StreamingResponse response;
+     nidaqmx_grpc::MonikerReadAnalogScalarF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -54,7 +54,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadBinaryI16StreamingResponse response;
+     nidaqmx_grpc::MonikerReadBinaryI16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -66,7 +66,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadBinaryI32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadBinaryI32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -78,7 +78,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadBinaryU16StreamingResponse response;
+     nidaqmx_grpc::MonikerReadBinaryU16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -90,7 +90,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadBinaryU32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadBinaryU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -101,7 +101,7 @@ namespace nidaqmx_grpc {
      float64 timeout;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterF64StreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -113,7 +113,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterF64ExStreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterF64ExResponse response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -122,7 +122,7 @@ namespace nidaqmx_grpc {
      TaskHandle task;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterScalarF64StreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterScalarF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -131,7 +131,7 @@ namespace nidaqmx_grpc {
      TaskHandle task;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterScalarU32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterScalarU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -142,7 +142,7 @@ namespace nidaqmx_grpc {
      float64 timeout;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterU32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -154,7 +154,82 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadCounterU32ExStreamingResponse response;
+     nidaqmx_grpc::MonikerReadCounterU32ExResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrFreqData
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 interleaved;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrFreqResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrFreqScalarData
+  {
+     TaskHandle task;
+     float64 timeout;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrFreqScalarResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrTicksData
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 interleaved;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrTicksResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrTicksScalarData
+  {
+     TaskHandle task;
+     float64 timeout;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrTicksScalarResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrTimeData
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 interleaved;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrTimeResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadCtrTimeScalarData
+  {
+     TaskHandle task;
+     float64 timeout;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadCtrTimeScalarResponse response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadDigitalLinesData
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 fill_mode;
+     uInt32 array_size_in_bytes;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadDigitalLinesResponse response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -163,7 +238,7 @@ namespace nidaqmx_grpc {
      TaskHandle task;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::ReadDigitalScalarU32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadDigitalScalarU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -175,7 +250,7 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadDigitalU16StreamingResponse response;
+     nidaqmx_grpc::MonikerReadDigitalU16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -187,7 +262,63 @@ namespace nidaqmx_grpc {
      int32 fill_mode;
      uInt32 array_size_in_samps;
      bool32* reserved;
-     nidaqmx_grpc::ReadDigitalU32StreamingResponse response;
+     nidaqmx_grpc::MonikerReadDigitalU32Response response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadDigitalU8Data
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 fill_mode;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadDigitalU8Response response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadPowerBinaryI16Data
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 fill_mode;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadPowerBinaryI16Response response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadPowerF64Data
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     int32 fill_mode;
+     uInt32 array_size_in_samps;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadPowerF64Response response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadPowerScalarF64Data
+  {
+     TaskHandle task;
+     float64 timeout;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadPowerScalarF64Response response;
+     std::shared_ptr<NiDAQmxLibraryInterface> library;
+  };
+
+  struct MonikerReadRawData
+  {
+     TaskHandle task;
+     int32 num_samps_per_chan;
+     float64 timeout;
+     uInt32 array_size_in_bytes;
+     bool32* reserved;
+     nidaqmx_grpc::MonikerReadRawResponse response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -195,7 +326,7 @@ namespace nidaqmx_grpc {
   {
      TaskHandle task;
      float64 timeout;
-     nidaqmx_grpc::WaitForNextSampleClockStreamingResponse response;
+     nidaqmx_grpc::MonikerWaitForNextSampleClockResponse response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -207,8 +338,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteAnalogF64StreamingRequest request;
-     nidaqmx_grpc::WriteAnalogF64StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteAnalogF64Request request;
+     nidaqmx_grpc::MonikerWriteAnalogF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -218,8 +349,8 @@ namespace nidaqmx_grpc {
      bool32 auto_start;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::WriteAnalogScalarF64StreamingRequest request;
-     nidaqmx_grpc::WriteAnalogScalarF64StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteAnalogScalarF64Request request;
+     nidaqmx_grpc::MonikerWriteAnalogScalarF64Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -231,8 +362,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteBinaryI16StreamingRequest request;
-     nidaqmx_grpc::WriteBinaryI16StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteBinaryI16Request request;
+     nidaqmx_grpc::MonikerWriteBinaryI16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -244,8 +375,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteBinaryI32StreamingRequest request;
-     nidaqmx_grpc::WriteBinaryI32StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteBinaryI32Request request;
+     nidaqmx_grpc::MonikerWriteBinaryI32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -257,8 +388,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteBinaryU16StreamingRequest request;
-     nidaqmx_grpc::WriteBinaryU16StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteBinaryU16Request request;
+     nidaqmx_grpc::MonikerWriteBinaryU16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -270,8 +401,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteBinaryU32StreamingRequest request;
-     nidaqmx_grpc::WriteBinaryU32StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteBinaryU32Request request;
+     nidaqmx_grpc::MonikerWriteBinaryU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -281,8 +412,8 @@ namespace nidaqmx_grpc {
      bool32 auto_start;
      float64 timeout;
      bool32* reserved;
-     nidaqmx_grpc::WriteDigitalScalarU32StreamingRequest request;
-     nidaqmx_grpc::WriteDigitalScalarU32StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteDigitalScalarU32Request request;
+     nidaqmx_grpc::MonikerWriteDigitalScalarU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -294,8 +425,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteDigitalU16StreamingRequest request;
-     nidaqmx_grpc::WriteDigitalU16StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteDigitalU16Request request;
+     nidaqmx_grpc::MonikerWriteDigitalU16Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -307,8 +438,8 @@ namespace nidaqmx_grpc {
      float64 timeout;
      int32 data_layout;
      bool32* reserved;
-     nidaqmx_grpc::WriteDigitalU32StreamingRequest request;
-     nidaqmx_grpc::WriteDigitalU32StreamingResponse response;
+     nidaqmx_grpc::MonikerWriteDigitalU32Request request;
+     nidaqmx_grpc::MonikerWriteDigitalU32Response response;
      std::shared_ptr<NiDAQmxLibraryInterface> library;
   };
 
@@ -349,9 +480,21 @@ namespace nidaqmx_grpc {
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCounterScalarU32", MonikerReadCounterScalarU32);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCounterU32", MonikerReadCounterU32);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCounterU32Ex", MonikerReadCounterU32Ex);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrFreq", MonikerReadCtrFreq);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrFreqScalar", MonikerReadCtrFreqScalar);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrTicks", MonikerReadCtrTicks);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrTicksScalar", MonikerReadCtrTicksScalar);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrTime", MonikerReadCtrTime);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadCtrTimeScalar", MonikerReadCtrTimeScalar);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadDigitalLines", MonikerReadDigitalLines);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadDigitalScalarU32", MonikerReadDigitalScalarU32);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadDigitalU16", MonikerReadDigitalU16);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadDigitalU32", MonikerReadDigitalU32);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadDigitalU8", MonikerReadDigitalU8);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadPowerBinaryI16", MonikerReadPowerBinaryI16);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadPowerF64", MonikerReadPowerF64);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadPowerScalarF64", MonikerReadPowerScalarF64);
+      ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerReadRaw", MonikerReadRaw);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerWaitForNextSampleClock", MonikerWaitForNextSampleClock);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerWriteAnalogF64", MonikerWriteAnalogF64);
       ni::data_monikers::DataMonikerService::RegisterMonikerEndpoint("MonikerWriteAnalogScalarF64", MonikerWriteAnalogScalarF64);
@@ -723,22 +866,29 @@ ::grpc::Status MonikerReadCounterU32Ex(void* data, google::protobuf::Arena& aren
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerReadDigitalScalarU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrFreq(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerReadDigitalScalarU32Data* function_data = static_cast<MonikerReadDigitalScalarU32Data*>(data);
+    MonikerReadCtrFreqData* function_data = static_cast<MonikerReadCtrFreqData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
     auto timeout = function_data->timeout;
+    auto interleaved = function_data->interleaved;
+    auto array_size_in_samps = function_data->array_size_in_samps;
     auto reserved = function_data->reserved;
-    uInt32 value {};
+    response->mutable_read_array_frequency()->Resize(array_size_in_samps, 0);
+    float64* read_array_frequency = response->mutable_read_array_frequency()->mutable_data();
+    response->mutable_read_array_duty_cycle()->Resize(array_size_in_samps, 0);
+    float64* read_array_duty_cycle = response->mutable_read_array_duty_cycle()->mutable_data();
+    int32 samps_per_chan_read {};
 
-    auto status = library->ReadDigitalScalarU32(task, timeout, &value, reserved);
+    auto status = library->ReadCtrFreq(task, num_samps_per_chan, timeout, interleaved, read_array_frequency, read_array_duty_cycle, array_size_in_samps, &samps_per_chan_read, reserved);
 
     if (status >= 0)
     {
       response->set_status(status);
-      response->set_value(value);
+      response->set_samps_per_chan_read(samps_per_chan_read);
       packedData.PackFrom(*response);
     }
     else
@@ -748,35 +898,24 @@ ::grpc::Status MonikerReadDigitalScalarU32(void* data, google::protobuf::Arena&
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerReadDigitalU16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrFreqScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerReadDigitalU16Data* function_data = static_cast<MonikerReadDigitalU16Data*>(data);
+    MonikerReadCtrFreqScalarData* function_data = static_cast<MonikerReadCtrFreqScalarData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
-    auto num_samps_per_chan = function_data->num_samps_per_chan;
     auto timeout = function_data->timeout;
-    auto fill_mode = function_data->fill_mode;
-    auto array_size_in_samps = function_data->array_size_in_samps;
     auto reserved = function_data->reserved;
-    std::vector<uInt16> read_array(array_size_in_samps);
-    int32 samps_per_chan_read {};
+    float64 frequency {};
+    float64 duty_cycle {};
 
-    auto status = library->ReadDigitalU16(task, num_samps_per_chan, timeout, fill_mode, read_array.data(), array_size_in_samps, &samps_per_chan_read, reserved);
+    auto status = library->ReadCtrFreqScalar(task, timeout, &frequency, &duty_cycle, reserved);
 
     if (status >= 0)
     {
       response->set_status(status);
-        response->mutable_read_array()->Clear();
-        response->mutable_read_array()->Reserve(array_size_in_samps);
-        std::transform(
-          read_array.begin(),
-          read_array.begin() + array_size_in_samps,
-          google::protobuf::RepeatedFieldBackInserter(response->mutable_read_array()),
-          [&](auto x) {
-              return x;
-          });
-      response->set_samps_per_chan_read(samps_per_chan_read);
+      response->set_frequency(frequency);
+      response->set_duty_cycle(duty_cycle);
       packedData.PackFrom(*response);
     }
     else
@@ -786,22 +925,24 @@ ::grpc::Status MonikerReadDigitalU16(void* data, google::protobuf::Arena& arena,
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerReadDigitalU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrTicks(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerReadDigitalU32Data* function_data = static_cast<MonikerReadDigitalU32Data*>(data);
+    MonikerReadCtrTicksData* function_data = static_cast<MonikerReadCtrTicksData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
     auto num_samps_per_chan = function_data->num_samps_per_chan;
     auto timeout = function_data->timeout;
-    auto fill_mode = function_data->fill_mode;
+    auto interleaved = function_data->interleaved;
     auto array_size_in_samps = function_data->array_size_in_samps;
     auto reserved = function_data->reserved;
-    response->mutable_read_array()->Resize(array_size_in_samps, 0);
-    uInt32* read_array = reinterpret_cast<uInt32*>(response->mutable_read_array()->mutable_data());
+    response->mutable_read_array_high_ticks()->Resize(array_size_in_samps, 0);
+    uInt32* read_array_high_ticks = reinterpret_cast<uInt32*>(response->mutable_read_array_high_ticks()->mutable_data());
+    response->mutable_read_array_low_ticks()->Resize(array_size_in_samps, 0);
+    uInt32* read_array_low_ticks = reinterpret_cast<uInt32*>(response->mutable_read_array_low_ticks()->mutable_data());
     int32 samps_per_chan_read {};
 
-    auto status = library->ReadDigitalU32(task, num_samps_per_chan, timeout, fill_mode, read_array, array_size_in_samps, &samps_per_chan_read, reserved);
+    auto status = library->ReadCtrTicks(task, num_samps_per_chan, timeout, interleaved, read_array_high_ticks, read_array_low_ticks, array_size_in_samps, &samps_per_chan_read, reserved);
 
     if (status >= 0)
     {
@@ -816,21 +957,24 @@ ::grpc::Status MonikerReadDigitalU32(void* data, google::protobuf::Arena& arena,
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWaitForNextSampleClock(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrTicksScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWaitForNextSampleClockData* function_data = static_cast<MonikerWaitForNextSampleClockData*>(data);
+    MonikerReadCtrTicksScalarData* function_data = static_cast<MonikerReadCtrTicksScalarData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
     auto timeout = function_data->timeout;
-    bool32 is_late {};
+    auto reserved = function_data->reserved;
+    uInt32 high_ticks {};
+    uInt32 low_ticks {};
 
-    auto status = library->WaitForNextSampleClock(task, timeout, &is_late);
+    auto status = library->ReadCtrTicksScalar(task, timeout, &high_ticks, &low_ticks, reserved);
 
     if (status >= 0)
     {
       response->set_status(status);
-      response->set_is_late(is_late);
+      response->set_high_ticks(high_ticks);
+      response->set_low_ticks(low_ticks);
       packedData.PackFrom(*response);
     }
     else
@@ -840,138 +984,514 @@ ::grpc::Status MonikerWaitForNextSampleClock(void* data, google::protobuf::Arena
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWriteAnalogF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrTime(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWriteAnalogF64Data* function_data = static_cast<MonikerWriteAnalogF64Data*>(data);
+    MonikerReadCtrTimeData* function_data = static_cast<MonikerReadCtrTimeData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
     auto num_samps_per_chan = function_data->num_samps_per_chan;
-    auto auto_start = function_data->auto_start;
     auto timeout = function_data->timeout;
-    auto data_layout = function_data->data_layout;
+    auto interleaved = function_data->interleaved;
+    auto array_size_in_samps = function_data->array_size_in_samps;
     auto reserved = function_data->reserved;
-    int32 samps_per_chan_written {};
-
-    ArrayDoubleData arraydoubledata_message;
-    packedData.UnpackTo(&arraydoubledata_message);
-    
-    auto data_array = arraydoubledata_message.value();
-    auto write_array = const_cast<const float64*>(arraydoubledata_message.value().data());
-    auto size = data_array.size();
+    response->mutable_read_array_high_time()->Resize(array_size_in_samps, 0);
+    float64* read_array_high_time = response->mutable_read_array_high_time()->mutable_data();
+    response->mutable_read_array_low_time()->Resize(array_size_in_samps, 0);
+    float64* read_array_low_time = response->mutable_read_array_low_time()->mutable_data();
+    int32 samps_per_chan_read {};
 
-    auto status = library->WriteAnalogF64(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array, &samps_per_chan_written, reserved);
+    auto status = library->ReadCtrTime(task, num_samps_per_chan, timeout, interleaved, read_array_high_time, read_array_low_time, array_size_in_samps, &samps_per_chan_read, reserved);
 
-    if (status < 0)
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
     {
       return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
     }
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWriteAnalogScalarF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadCtrTimeScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWriteAnalogScalarF64Data* function_data = static_cast<MonikerWriteAnalogScalarF64Data*>(data);
+    MonikerReadCtrTimeScalarData* function_data = static_cast<MonikerReadCtrTimeScalarData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
-    auto auto_start = function_data->auto_start;
     auto timeout = function_data->timeout;
     auto reserved = function_data->reserved;
+    float64 high_time {};
+    float64 low_time {};
 
-    DoubleData doubledata_message;
-    packedData.UnpackTo(&doubledata_message);
-    auto value = doubledata_message.value();
-
-    auto status = library->WriteAnalogScalarF64(task, auto_start, timeout, value, reserved);
+    auto status = library->ReadCtrTimeScalar(task, timeout, &high_time, &low_time, reserved);
 
-    if (status < 0)
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_high_time(high_time);
+      response->set_low_time(low_time);
+      packedData.PackFrom(*response);
+    }
+    else
     {
       return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
     }
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWriteBinaryI16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadDigitalLines(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWriteBinaryI16Data* function_data = static_cast<MonikerWriteBinaryI16Data*>(data);
+    MonikerReadDigitalLinesData* function_data = static_cast<MonikerReadDigitalLinesData*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
     auto num_samps_per_chan = function_data->num_samps_per_chan;
-    auto auto_start = function_data->auto_start;
     auto timeout = function_data->timeout;
-    auto data_layout = function_data->data_layout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_bytes = function_data->array_size_in_bytes;
     auto reserved = function_data->reserved;
-    int32 samps_per_chan_written {};
-
-    ArrayI16Data arrayi16data_message;
-    packedData.UnpackTo(&arrayi16data_message);
-    
-    auto data_array = arrayi16data_message.value();
-    auto write_array = std::vector<int16>();
-    auto size = data_array.size();
-    write_array.reserve(size);
-    std::transform(
-      data_array.begin(),
-      data_array.end(),
-      std::back_inserter(write_array),
-      [](auto x) {
-        if (x < std::numeric_limits<int16>::min() || x > std::numeric_limits<int16>::max()) {
-          std::string message("value " + std::to_string(x) + " doesn't fit in datatype int16");
-          throw nidevice_grpc::ValueOutOfRangeException(message);
-        }
-        return static_cast<int16>(x);
-      });
+    std::string read_array(array_size_in_bytes, '\0');
+    int32 samps_per_chan_read {};
+    int32 num_bytes_per_samp {};
 
-    auto status = library->WriteBinaryI16(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array.data(), &samps_per_chan_written, reserved);
+    auto status = library->ReadDigitalLines(task, num_samps_per_chan, timeout, fill_mode, (uInt8*)read_array.data(), array_size_in_bytes, &samps_per_chan_read, &num_bytes_per_samp, reserved);
 
-    if (status < 0)
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_read_array(read_array);
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      response->set_num_bytes_per_samp(num_bytes_per_samp);
+      packedData.PackFrom(*response);
+    }
+    else
     {
       return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
     }
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWriteBinaryI32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadDigitalScalarU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWriteBinaryI32Data* function_data = static_cast<MonikerWriteBinaryI32Data*>(data);
+    MonikerReadDigitalScalarU32Data* function_data = static_cast<MonikerReadDigitalScalarU32Data*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
-    auto num_samps_per_chan = function_data->num_samps_per_chan;
-    auto auto_start = function_data->auto_start;
     auto timeout = function_data->timeout;
-    auto data_layout = function_data->data_layout;
     auto reserved = function_data->reserved;
-    int32 samps_per_chan_written {};
-
-    ArrayI32Data arrayi32data_message;
-    packedData.UnpackTo(&arrayi32data_message);
-    
-    auto data_array = arrayi32data_message.value();
-    auto write_array = reinterpret_cast<const int32*>(arrayi32data_message.value().data());
-    auto size = data_array.size();
+    uInt32 value {};
 
-    auto status = library->WriteBinaryI32(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array, &samps_per_chan_written, reserved);
+    auto status = library->ReadDigitalScalarU32(task, timeout, &value, reserved);
 
-    if (status < 0)
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_value(value);
+      packedData.PackFrom(*response);
+    }
+    else
     {
       return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
     }
     return ::grpc::Status::OK;
 }
 
-::grpc::Status MonikerWriteBinaryU16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+::grpc::Status MonikerReadDigitalU16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
 {
-    MonikerWriteBinaryU16Data* function_data = static_cast<MonikerWriteBinaryU16Data*>(data);
+    MonikerReadDigitalU16Data* function_data = static_cast<MonikerReadDigitalU16Data*>(data);
     auto library = function_data->library;
     auto response = &function_data->response;
     auto task = function_data->task;
     auto num_samps_per_chan = function_data->num_samps_per_chan;
-    auto auto_start = function_data->auto_start;
     auto timeout = function_data->timeout;
-    auto data_layout = function_data->data_layout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_samps = function_data->array_size_in_samps;
+    auto reserved = function_data->reserved;
+    std::vector<uInt16> read_array(array_size_in_samps);
+    int32 samps_per_chan_read {};
+
+    auto status = library->ReadDigitalU16(task, num_samps_per_chan, timeout, fill_mode, read_array.data(), array_size_in_samps, &samps_per_chan_read, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+        response->mutable_read_array()->Clear();
+        response->mutable_read_array()->Reserve(array_size_in_samps);
+        std::transform(
+          read_array.begin(),
+          read_array.begin() + array_size_in_samps,
+          google::protobuf::RepeatedFieldBackInserter(response->mutable_read_array()),
+          [&](auto x) {
+              return x;
+          });
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadDigitalU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadDigitalU32Data* function_data = static_cast<MonikerReadDigitalU32Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto timeout = function_data->timeout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_samps = function_data->array_size_in_samps;
+    auto reserved = function_data->reserved;
+    response->mutable_read_array()->Resize(array_size_in_samps, 0);
+    uInt32* read_array = reinterpret_cast<uInt32*>(response->mutable_read_array()->mutable_data());
+    int32 samps_per_chan_read {};
+
+    auto status = library->ReadDigitalU32(task, num_samps_per_chan, timeout, fill_mode, read_array, array_size_in_samps, &samps_per_chan_read, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadDigitalU8(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadDigitalU8Data* function_data = static_cast<MonikerReadDigitalU8Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto timeout = function_data->timeout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_samps = function_data->array_size_in_samps;
+    auto reserved = function_data->reserved;
+    std::string read_array(array_size_in_samps, '\0');
+    int32 samps_per_chan_read {};
+
+    auto status = library->ReadDigitalU8(task, num_samps_per_chan, timeout, fill_mode, (uInt8*)read_array.data(), array_size_in_samps, &samps_per_chan_read, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_read_array(read_array);
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadPowerBinaryI16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadPowerBinaryI16Data* function_data = static_cast<MonikerReadPowerBinaryI16Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto timeout = function_data->timeout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_samps = function_data->array_size_in_samps;
+    auto reserved = function_data->reserved;
+    std::vector<int16> read_array_voltage(array_size_in_samps);
+    std::vector<int16> read_array_current(array_size_in_samps);
+    int32 samps_per_chan_read {};
+
+    auto status = library->ReadPowerBinaryI16(task, num_samps_per_chan, timeout, fill_mode, read_array_voltage.data(), read_array_current.data(), array_size_in_samps, &samps_per_chan_read, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+        response->mutable_read_array_voltage()->Clear();
+        response->mutable_read_array_voltage()->Reserve(array_size_in_samps);
+        std::transform(
+          read_array_voltage.begin(),
+          read_array_voltage.begin() + array_size_in_samps,
+          google::protobuf::RepeatedFieldBackInserter(response->mutable_read_array_voltage()),
+          [&](auto x) {
+              return x;
+          });
+        response->mutable_read_array_current()->Clear();
+        response->mutable_read_array_current()->Reserve(array_size_in_samps);
+        std::transform(
+          read_array_current.begin(),
+          read_array_current.begin() + array_size_in_samps,
+          google::protobuf::RepeatedFieldBackInserter(response->mutable_read_array_current()),
+          [&](auto x) {
+              return x;
+          });
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadPowerF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadPowerF64Data* function_data = static_cast<MonikerReadPowerF64Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto timeout = function_data->timeout;
+    auto fill_mode = function_data->fill_mode;
+    auto array_size_in_samps = function_data->array_size_in_samps;
+    auto reserved = function_data->reserved;
+    response->mutable_read_array_voltage()->Resize(array_size_in_samps, 0);
+    float64* read_array_voltage = response->mutable_read_array_voltage()->mutable_data();
+    response->mutable_read_array_current()->Resize(array_size_in_samps, 0);
+    float64* read_array_current = response->mutable_read_array_current()->mutable_data();
+    int32 samps_per_chan_read {};
+
+    auto status = library->ReadPowerF64(task, num_samps_per_chan, timeout, fill_mode, read_array_voltage, read_array_current, array_size_in_samps, &samps_per_chan_read, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_samps_per_chan_read(samps_per_chan_read);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadPowerScalarF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadPowerScalarF64Data* function_data = static_cast<MonikerReadPowerScalarF64Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto timeout = function_data->timeout;
+    auto reserved = function_data->reserved;
+    float64 voltage {};
+    float64 current {};
+
+    auto status = library->ReadPowerScalarF64(task, timeout, &voltage, &current, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_voltage(voltage);
+      response->set_current(current);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerReadRaw(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerReadRawData* function_data = static_cast<MonikerReadRawData*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto timeout = function_data->timeout;
+    auto array_size_in_bytes = function_data->array_size_in_bytes;
+    auto reserved = function_data->reserved;
+    std::string read_array(array_size_in_bytes, '\0');
+    int32 samps_read {};
+    int32 num_bytes_per_samp {};
+
+    auto status = library->ReadRaw(task, num_samps_per_chan, timeout, (uInt8*)read_array.data(), array_size_in_bytes, &samps_read, &num_bytes_per_samp, reserved);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_read_array(read_array);
+      response->set_samps_read(samps_read);
+      response->set_num_bytes_per_samp(num_bytes_per_samp);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWaitForNextSampleClock(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWaitForNextSampleClockData* function_data = static_cast<MonikerWaitForNextSampleClockData*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto timeout = function_data->timeout;
+    bool32 is_late {};
+
+    auto status = library->WaitForNextSampleClock(task, timeout, &is_late);
+
+    if (status >= 0)
+    {
+      response->set_status(status);
+      response->set_is_late(is_late);
+      packedData.PackFrom(*response);
+    }
+    else
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWriteAnalogF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWriteAnalogF64Data* function_data = static_cast<MonikerWriteAnalogF64Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto auto_start = function_data->auto_start;
+    auto timeout = function_data->timeout;
+    auto data_layout = function_data->data_layout;
+    auto reserved = function_data->reserved;
+    int32 samps_per_chan_written {};
+
+    ArrayDoubleData arraydoubledata_message;
+    packedData.UnpackTo(&arraydoubledata_message);
+    
+    auto data_array = arraydoubledata_message.value();
+    auto write_array = const_cast<const float64*>(arraydoubledata_message.value().data());
+    auto size = data_array.size();
+
+    auto status = library->WriteAnalogF64(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array, &samps_per_chan_written, reserved);
+
+    if (status < 0)
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWriteAnalogScalarF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWriteAnalogScalarF64Data* function_data = static_cast<MonikerWriteAnalogScalarF64Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto auto_start = function_data->auto_start;
+    auto timeout = function_data->timeout;
+    auto reserved = function_data->reserved;
+
+    DoubleData doubledata_message;
+    packedData.UnpackTo(&doubledata_message);
+    auto value = doubledata_message.value();
+
+    auto status = library->WriteAnalogScalarF64(task, auto_start, timeout, value, reserved);
+
+    if (status < 0)
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWriteBinaryI16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWriteBinaryI16Data* function_data = static_cast<MonikerWriteBinaryI16Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto auto_start = function_data->auto_start;
+    auto timeout = function_data->timeout;
+    auto data_layout = function_data->data_layout;
+    auto reserved = function_data->reserved;
+    int32 samps_per_chan_written {};
+
+    ArrayI16Data arrayi16data_message;
+    packedData.UnpackTo(&arrayi16data_message);
+    
+    auto data_array = arrayi16data_message.value();
+    auto write_array = std::vector<int16>();
+    auto size = data_array.size();
+    write_array.reserve(size);
+    std::transform(
+      data_array.begin(),
+      data_array.end(),
+      std::back_inserter(write_array),
+      [](auto x) {
+        if (x < std::numeric_limits<int16>::min() || x > std::numeric_limits<int16>::max()) {
+          std::string message("value " + std::to_string(x) + " doesn't fit in datatype int16");
+          throw nidevice_grpc::ValueOutOfRangeException(message);
+        }
+        return static_cast<int16>(x);
+      });
+
+    auto status = library->WriteBinaryI16(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array.data(), &samps_per_chan_written, reserved);
+
+    if (status < 0)
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWriteBinaryI32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWriteBinaryI32Data* function_data = static_cast<MonikerWriteBinaryI32Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto auto_start = function_data->auto_start;
+    auto timeout = function_data->timeout;
+    auto data_layout = function_data->data_layout;
+    auto reserved = function_data->reserved;
+    int32 samps_per_chan_written {};
+
+    ArrayI32Data arrayi32data_message;
+    packedData.UnpackTo(&arrayi32data_message);
+    
+    auto data_array = arrayi32data_message.value();
+    auto write_array = reinterpret_cast<const int32*>(arrayi32data_message.value().data());
+    auto size = data_array.size();
+
+    auto status = library->WriteBinaryI32(task, num_samps_per_chan, auto_start, timeout, data_layout, write_array, &samps_per_chan_written, reserved);
+
+    if (status < 0)
+    {
+      return ::grpc::Status(grpc::StatusCode::UNKNOWN, "ni-error: " + status);
+    }
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status MonikerWriteBinaryU16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData)
+{
+    MonikerWriteBinaryU16Data* function_data = static_cast<MonikerWriteBinaryU16Data*>(data);
+    auto library = function_data->library;
+    auto response = &function_data->response;
+    auto task = function_data->task;
+    auto num_samps_per_chan = function_data->num_samps_per_chan;
+    auto auto_start = function_data->auto_start;
+    auto timeout = function_data->timeout;
+    auto data_layout = function_data->data_layout;
     auto reserved = function_data->reserved;
     int32 samps_per_chan_written {};
 
@@ -15305,6 +15825,61 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadCtrFreq(::grpc::ServerContext* context, const BeginReadCtrFreqRequest* request, BeginReadCtrFreqResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 interleaved;
+      switch (request->interleaved_enum_case()) {
+        case nidaqmx_grpc::BeginReadCtrFreqRequest::InterleavedEnumCase::kInterleaved: {
+          interleaved = static_cast<int32>(request->interleaved());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrFreqRequest::InterleavedEnumCase::kInterleavedRaw: {
+          interleaved = static_cast<int32>(request->interleaved_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrFreqRequest::InterleavedEnumCase::INTERLEAVED_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for interleaved was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadCtrFreqData>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->interleaved = interleaved;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array_frequency()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_frequency()->Resize(request->array_size_in_samps(), 0);
+      data->response.mutable_read_array_duty_cycle()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_duty_cycle()->Resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrFreq", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadCtrFreqScalar(::grpc::ServerContext* context, const ReadCtrFreqScalarRequest* request, ReadCtrFreqScalarResponse* response)
@@ -15333,6 +15908,36 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadCtrFreqScalar(::grpc::ServerContext* context, const BeginReadCtrFreqScalarRequest* request, BeginReadCtrFreqScalarResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      float64 timeout = request->timeout();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadCtrFreqScalarData>();
+      data->task = task;
+      data->timeout = timeout;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrFreqScalar", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadCtrTicks(::grpc::ServerContext* context, const ReadCtrTicksRequest* request, ReadCtrTicksResponse* response)
@@ -15382,6 +15987,61 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadCtrTicks(::grpc::ServerContext* context, const BeginReadCtrTicksRequest* request, BeginReadCtrTicksResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 interleaved;
+      switch (request->interleaved_enum_case()) {
+        case nidaqmx_grpc::BeginReadCtrTicksRequest::InterleavedEnumCase::kInterleaved: {
+          interleaved = static_cast<int32>(request->interleaved());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrTicksRequest::InterleavedEnumCase::kInterleavedRaw: {
+          interleaved = static_cast<int32>(request->interleaved_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrTicksRequest::InterleavedEnumCase::INTERLEAVED_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for interleaved was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadCtrTicksData>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->interleaved = interleaved;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array_high_ticks()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_high_ticks()->Resize(request->array_size_in_samps(), 0);
+      data->response.mutable_read_array_low_ticks()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_low_ticks()->Resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrTicks", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadCtrTicksScalar(::grpc::ServerContext* context, const ReadCtrTicksScalarRequest* request, ReadCtrTicksScalarResponse* response)
@@ -15410,6 +16070,36 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadCtrTicksScalar(::grpc::ServerContext* context, const BeginReadCtrTicksScalarRequest* request, BeginReadCtrTicksScalarResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      float64 timeout = request->timeout();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadCtrTicksScalarData>();
+      data->task = task;
+      data->timeout = timeout;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrTicksScalar", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadCtrTime(::grpc::ServerContext* context, const ReadCtrTimeRequest* request, ReadCtrTimeResponse* response)
@@ -15461,7 +16151,90 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
-  ::grpc::Status NiDAQmxService::ReadCtrTimeScalar(::grpc::ServerContext* context, const ReadCtrTimeScalarRequest* request, ReadCtrTimeScalarResponse* response)
+  ::grpc::Status NiDAQmxService::BeginReadCtrTime(::grpc::ServerContext* context, const BeginReadCtrTimeRequest* request, BeginReadCtrTimeResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 interleaved;
+      switch (request->interleaved_enum_case()) {
+        case nidaqmx_grpc::BeginReadCtrTimeRequest::InterleavedEnumCase::kInterleaved: {
+          interleaved = static_cast<int32>(request->interleaved());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrTimeRequest::InterleavedEnumCase::kInterleavedRaw: {
+          interleaved = static_cast<int32>(request->interleaved_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadCtrTimeRequest::InterleavedEnumCase::INTERLEAVED_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for interleaved was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadCtrTimeData>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->interleaved = interleaved;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array_high_time()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_high_time()->Resize(request->array_size_in_samps(), 0);
+      data->response.mutable_read_array_low_time()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_low_time()->Resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrTime", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::ReadCtrTimeScalar(::grpc::ServerContext* context, const ReadCtrTimeScalarRequest* request, ReadCtrTimeScalarResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      float64 timeout = request->timeout();
+      auto reserved = nullptr;
+      float64 high_time {};
+      float64 low_time {};
+      auto status = library_->ReadCtrTimeScalar(task, timeout, &high_time, &low_time, reserved);
+      if (!status_ok(status)) {
+        return ConvertApiErrorStatusForTaskHandle(context, status, task);
+      }
+      response->set_status(status);
+      response->set_high_time(high_time);
+      response->set_low_time(low_time);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadCtrTimeScalar(::grpc::ServerContext* context, const BeginReadCtrTimeScalarRequest* request, BeginReadCtrTimeScalarResponse* response)
   {
     if (context->IsCancelled()) {
       return ::grpc::Status::CANCELLED;
@@ -15471,15 +16244,17 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
       TaskHandle task = session_repository_->access_session(task_grpc_session.name());
       float64 timeout = request->timeout();
       auto reserved = nullptr;
-      float64 high_time {};
-      float64 low_time {};
-      auto status = library_->ReadCtrTimeScalar(task, timeout, &high_time, &low_time, reserved);
-      if (!status_ok(status)) {
-        return ConvertApiErrorStatusForTaskHandle(context, status, task);
-      }
-      response->set_status(status);
-      response->set_high_time(high_time);
-      response->set_low_time(low_time);
+
+      auto data = std::make_unique<MonikerReadCtrTimeScalarData>();
+      data->task = task;
+      data->timeout = timeout;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadCtrTimeScalar", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
       return ::grpc::Status::OK;
     }
     catch (nidevice_grpc::NonDriverException& ex) {
@@ -15536,6 +16311,59 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadDigitalLines(::grpc::ServerContext* context, const BeginReadDigitalLinesRequest* request, BeginReadDigitalLinesResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 fill_mode;
+      switch (request->fill_mode_enum_case()) {
+        case nidaqmx_grpc::BeginReadDigitalLinesRequest::FillModeEnumCase::kFillMode: {
+          fill_mode = static_cast<int32>(request->fill_mode());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadDigitalLinesRequest::FillModeEnumCase::kFillModeRaw: {
+          fill_mode = static_cast<int32>(request->fill_mode_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadDigitalLinesRequest::FillModeEnumCase::FILL_MODE_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for fill_mode was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_bytes = request->array_size_in_bytes();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadDigitalLinesData>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->fill_mode = fill_mode;
+      data->array_size_in_bytes = array_size_in_bytes;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array()->reserve(request->array_size_in_bytes());
+      data->response.mutable_read_array()->resize(request->array_size_in_bytes(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadDigitalLines", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadDigitalScalarU32(::grpc::ServerContext* context, const ReadDigitalScalarU32Request* request, ReadDigitalScalarU32Response* response)
@@ -15847,6 +16675,59 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadDigitalU8(::grpc::ServerContext* context, const BeginReadDigitalU8Request* request, BeginReadDigitalU8Response* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 fill_mode;
+      switch (request->fill_mode_enum_case()) {
+        case nidaqmx_grpc::BeginReadDigitalU8Request::FillModeEnumCase::kFillMode: {
+          fill_mode = static_cast<int32>(request->fill_mode());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadDigitalU8Request::FillModeEnumCase::kFillModeRaw: {
+          fill_mode = static_cast<int32>(request->fill_mode_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadDigitalU8Request::FillModeEnumCase::FILL_MODE_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for fill_mode was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadDigitalU8Data>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->fill_mode = fill_mode;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array()->reserve(request->array_size_in_samps());
+      data->response.mutable_read_array()->resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadDigitalU8", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadPowerBinaryI16(::grpc::ServerContext* context, const ReadPowerBinaryI16Request* request, ReadPowerBinaryI16Response* response)
@@ -15912,6 +16793,61 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadPowerBinaryI16(::grpc::ServerContext* context, const BeginReadPowerBinaryI16Request* request, BeginReadPowerBinaryI16Response* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 fill_mode;
+      switch (request->fill_mode_enum_case()) {
+        case nidaqmx_grpc::BeginReadPowerBinaryI16Request::FillModeEnumCase::kFillMode: {
+          fill_mode = static_cast<int32>(request->fill_mode());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadPowerBinaryI16Request::FillModeEnumCase::kFillModeRaw: {
+          fill_mode = static_cast<int32>(request->fill_mode_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadPowerBinaryI16Request::FillModeEnumCase::FILL_MODE_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for fill_mode was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadPowerBinaryI16Data>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->fill_mode = fill_mode;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array_voltage()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_voltage()->Resize(request->array_size_in_samps(), 0);
+      data->response.mutable_read_array_current()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_current()->Resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadPowerBinaryI16", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadPowerF64(::grpc::ServerContext* context, const ReadPowerF64Request* request, ReadPowerF64Response* response)
@@ -15961,6 +16897,61 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadPowerF64(::grpc::ServerContext* context, const BeginReadPowerF64Request* request, BeginReadPowerF64Response* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      int32 fill_mode;
+      switch (request->fill_mode_enum_case()) {
+        case nidaqmx_grpc::BeginReadPowerF64Request::FillModeEnumCase::kFillMode: {
+          fill_mode = static_cast<int32>(request->fill_mode());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadPowerF64Request::FillModeEnumCase::kFillModeRaw: {
+          fill_mode = static_cast<int32>(request->fill_mode_raw());
+          break;
+        }
+        case nidaqmx_grpc::BeginReadPowerF64Request::FillModeEnumCase::FILL_MODE_ENUM_NOT_SET: {
+          return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The value for fill_mode was not specified or out of range");
+          break;
+        }
+      }
+
+      uInt32 array_size_in_samps = request->array_size_in_samps();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadPowerF64Data>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->fill_mode = fill_mode;
+      data->array_size_in_samps = array_size_in_samps;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array_voltage()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_voltage()->Resize(request->array_size_in_samps(), 0);
+      data->response.mutable_read_array_current()->Reserve(request->array_size_in_samps());
+      data->response.mutable_read_array_current()->Resize(request->array_size_in_samps(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadPowerF64", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadPowerScalarF64(::grpc::ServerContext* context, const ReadPowerScalarF64Request* request, ReadPowerScalarF64Response* response)
@@ -15989,6 +16980,36 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadPowerScalarF64(::grpc::ServerContext* context, const BeginReadPowerScalarF64Request* request, BeginReadPowerScalarF64Response* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      float64 timeout = request->timeout();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadPowerScalarF64Data>();
+      data->task = task;
+      data->timeout = timeout;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadPowerScalarF64", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::Status NiDAQmxService::ReadRaw(::grpc::ServerContext* context, const ReadRawRequest* request, ReadRawResponse* response)
@@ -16022,6 +17043,42 @@ ::grpc::Status MonikerWriteDigitalU32(void* data, google::protobuf::Arena& arena
     }
   }
 
+  //---------------------------------------------------------------------
+  //---------------------------------------------------------------------
+  ::grpc::Status NiDAQmxService::BeginReadRaw(::grpc::ServerContext* context, const BeginReadRawRequest* request, BeginReadRawResponse* response)
+  {
+    if (context->IsCancelled()) {
+      return ::grpc::Status::CANCELLED;
+    }
+    try {
+      auto task_grpc_session = request->task();
+      TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+      int32 num_samps_per_chan = request->num_samps_per_chan();
+      float64 timeout = request->timeout();
+      uInt32 array_size_in_bytes = request->array_size_in_bytes();
+      auto reserved = nullptr;
+
+      auto data = std::make_unique<MonikerReadRawData>();
+      data->task = task;
+      data->num_samps_per_chan = num_samps_per_chan;
+      data->timeout = timeout;
+      data->array_size_in_bytes = array_size_in_bytes;
+      data->reserved = reserved;
+      data->library = std::shared_ptr<NiDAQmxLibraryInterface>(library_);
+
+      data->response.mutable_read_array()->reserve(request->array_size_in_bytes());
+      data->response.mutable_read_array()->resize(request->array_size_in_bytes(), 0);
+      auto moniker = std::make_unique<ni::data_monikers::Moniker>();
+      ni::data_monikers::DataMonikerService::RegisterMonikerInstance("MonikerReadRaw", data.release(), *moniker);
+      response->set_allocated_moniker(moniker.release());
+      response->set_status(0);
+      return ::grpc::Status::OK;
+    }
+    catch (nidevice_grpc::NonDriverException& ex) {
+      return ex.GetStatus();
+    }
+  }
+
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   ::grpc::ServerWriteReactor<RegisterDoneEventResponse>*
diff --git a/generated/nidaqmx/nidaqmx_service.h b/generated/nidaqmx/nidaqmx_service.h
index 03c2324d1..fa8045f32 100644
--- a/generated/nidaqmx/nidaqmx_service.h
+++ b/generated/nidaqmx/nidaqmx_service.h
@@ -46,9 +46,21 @@ ::grpc::Status MonikerReadCounterScalarF64(void* data, google::protobuf::Arena&
 ::grpc::Status MonikerReadCounterScalarU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerReadCounterU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerReadCounterU32Ex(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrFreq(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrFreqScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrTicks(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrTicksScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrTime(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadCtrTimeScalar(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadDigitalLines(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerReadDigitalScalarU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerReadDigitalU16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerReadDigitalU32(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadDigitalU8(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadPowerBinaryI16(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadPowerF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadPowerScalarF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
+::grpc::Status MonikerReadRaw(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerWaitForNextSampleClock(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerWriteAnalogF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
 ::grpc::Status MonikerWriteAnalogScalarF64(void* data, google::protobuf::Arena& arena, google::protobuf::Any& packedData);
@@ -341,12 +353,19 @@ class NiDAQmxService final : public NiDAQmx::WithCallbackMethod_RegisterSignalEv
   ::grpc::Status ReadCounterU32Ex(::grpc::ServerContext* context, const ReadCounterU32ExRequest* request, ReadCounterU32ExResponse* response) override;
   ::grpc::Status BeginReadCounterU32Ex(::grpc::ServerContext* context, const BeginReadCounterU32ExRequest* request, BeginReadCounterU32ExResponse* response) override;
   ::grpc::Status ReadCtrFreq(::grpc::ServerContext* context, const ReadCtrFreqRequest* request, ReadCtrFreqResponse* response) override;
+  ::grpc::Status BeginReadCtrFreq(::grpc::ServerContext* context, const BeginReadCtrFreqRequest* request, BeginReadCtrFreqResponse* response) override;
   ::grpc::Status ReadCtrFreqScalar(::grpc::ServerContext* context, const ReadCtrFreqScalarRequest* request, ReadCtrFreqScalarResponse* response) override;
+  ::grpc::Status BeginReadCtrFreqScalar(::grpc::ServerContext* context, const BeginReadCtrFreqScalarRequest* request, BeginReadCtrFreqScalarResponse* response) override;
   ::grpc::Status ReadCtrTicks(::grpc::ServerContext* context, const ReadCtrTicksRequest* request, ReadCtrTicksResponse* response) override;
+  ::grpc::Status BeginReadCtrTicks(::grpc::ServerContext* context, const BeginReadCtrTicksRequest* request, BeginReadCtrTicksResponse* response) override;
   ::grpc::Status ReadCtrTicksScalar(::grpc::ServerContext* context, const ReadCtrTicksScalarRequest* request, ReadCtrTicksScalarResponse* response) override;
+  ::grpc::Status BeginReadCtrTicksScalar(::grpc::ServerContext* context, const BeginReadCtrTicksScalarRequest* request, BeginReadCtrTicksScalarResponse* response) override;
   ::grpc::Status ReadCtrTime(::grpc::ServerContext* context, const ReadCtrTimeRequest* request, ReadCtrTimeResponse* response) override;
+  ::grpc::Status BeginReadCtrTime(::grpc::ServerContext* context, const BeginReadCtrTimeRequest* request, BeginReadCtrTimeResponse* response) override;
   ::grpc::Status ReadCtrTimeScalar(::grpc::ServerContext* context, const ReadCtrTimeScalarRequest* request, ReadCtrTimeScalarResponse* response) override;
+  ::grpc::Status BeginReadCtrTimeScalar(::grpc::ServerContext* context, const BeginReadCtrTimeScalarRequest* request, BeginReadCtrTimeScalarResponse* response) override;
   ::grpc::Status ReadDigitalLines(::grpc::ServerContext* context, const ReadDigitalLinesRequest* request, ReadDigitalLinesResponse* response) override;
+  ::grpc::Status BeginReadDigitalLines(::grpc::ServerContext* context, const BeginReadDigitalLinesRequest* request, BeginReadDigitalLinesResponse* response) override;
   ::grpc::Status ReadDigitalScalarU32(::grpc::ServerContext* context, const ReadDigitalScalarU32Request* request, ReadDigitalScalarU32Response* response) override;
   ::grpc::Status BeginReadDigitalScalarU32(::grpc::ServerContext* context, const BeginReadDigitalScalarU32Request* request, BeginReadDigitalScalarU32Response* response) override;
   ::grpc::Status ReadDigitalU16(::grpc::ServerContext* context, const ReadDigitalU16Request* request, ReadDigitalU16Response* response) override;
@@ -354,10 +373,15 @@ class NiDAQmxService final : public NiDAQmx::WithCallbackMethod_RegisterSignalEv
   ::grpc::Status ReadDigitalU32(::grpc::ServerContext* context, const ReadDigitalU32Request* request, ReadDigitalU32Response* response) override;
   ::grpc::Status BeginReadDigitalU32(::grpc::ServerContext* context, const BeginReadDigitalU32Request* request, BeginReadDigitalU32Response* response) override;
   ::grpc::Status ReadDigitalU8(::grpc::ServerContext* context, const ReadDigitalU8Request* request, ReadDigitalU8Response* response) override;
+  ::grpc::Status BeginReadDigitalU8(::grpc::ServerContext* context, const BeginReadDigitalU8Request* request, BeginReadDigitalU8Response* response) override;
   ::grpc::Status ReadPowerBinaryI16(::grpc::ServerContext* context, const ReadPowerBinaryI16Request* request, ReadPowerBinaryI16Response* response) override;
+  ::grpc::Status BeginReadPowerBinaryI16(::grpc::ServerContext* context, const BeginReadPowerBinaryI16Request* request, BeginReadPowerBinaryI16Response* response) override;
   ::grpc::Status ReadPowerF64(::grpc::ServerContext* context, const ReadPowerF64Request* request, ReadPowerF64Response* response) override;
+  ::grpc::Status BeginReadPowerF64(::grpc::ServerContext* context, const BeginReadPowerF64Request* request, BeginReadPowerF64Response* response) override;
   ::grpc::Status ReadPowerScalarF64(::grpc::ServerContext* context, const ReadPowerScalarF64Request* request, ReadPowerScalarF64Response* response) override;
+  ::grpc::Status BeginReadPowerScalarF64(::grpc::ServerContext* context, const BeginReadPowerScalarF64Request* request, BeginReadPowerScalarF64Response* response) override;
   ::grpc::Status ReadRaw(::grpc::ServerContext* context, const ReadRawRequest* request, ReadRawResponse* response) override;
+  ::grpc::Status BeginReadRaw(::grpc::ServerContext* context, const BeginReadRawRequest* request, BeginReadRawResponse* response) override;
   ::grpc::ServerWriteReactor<RegisterDoneEventResponse>* RegisterDoneEvent(::grpc::CallbackServerContext* context, const RegisterDoneEventRequest* request) override;
   ::grpc::ServerWriteReactor<RegisterEveryNSamplesEventResponse>* RegisterEveryNSamplesEvent(::grpc::CallbackServerContext* context, const RegisterEveryNSamplesEventRequest* request) override;
   ::grpc::ServerWriteReactor<RegisterSignalEventResponse>* RegisterSignalEvent(::grpc::CallbackServerContext* context, const RegisterSignalEventRequest* request) override;
diff --git a/generated/nifpga/nifpga.proto b/generated/nifpga/nifpga.proto
index 70c1f74ad..ec6660e20 100644
--- a/generated/nifpga/nifpga.proto
+++ b/generated/nifpga/nifpga.proto
@@ -502,7 +502,7 @@ message BeginReadArrayBoolResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayBoolStreamingResponse {
+message MonikerReadArrayBoolResponse {
   int32 status = 1;
   repeated bool array = 2;
 }
@@ -529,7 +529,7 @@ message BeginReadArrayDblResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayDblStreamingResponse {
+message MonikerReadArrayDblResponse {
   int32 status = 1;
   repeated double array = 2;
 }
@@ -556,7 +556,7 @@ message BeginReadArrayI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayI16StreamingResponse {
+message MonikerReadArrayI16Response {
   int32 status = 1;
   repeated int32 array = 2;
 }
@@ -583,7 +583,7 @@ message BeginReadArrayI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayI32StreamingResponse {
+message MonikerReadArrayI32Response {
   int32 status = 1;
   repeated int32 array = 2;
 }
@@ -610,7 +610,7 @@ message BeginReadArrayI64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayI64StreamingResponse {
+message MonikerReadArrayI64Response {
   int32 status = 1;
   repeated int64 array = 2;
 }
@@ -637,7 +637,7 @@ message BeginReadArrayI8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayI8StreamingResponse {
+message MonikerReadArrayI8Response {
   int32 status = 1;
   repeated int32 array = 2;
 }
@@ -664,7 +664,7 @@ message BeginReadArraySglResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArraySglStreamingResponse {
+message MonikerReadArraySglResponse {
   int32 status = 1;
   repeated float array = 2;
 }
@@ -691,7 +691,7 @@ message BeginReadArrayU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayU16StreamingResponse {
+message MonikerReadArrayU16Response {
   int32 status = 1;
   repeated uint32 array = 2;
 }
@@ -718,7 +718,7 @@ message BeginReadArrayU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayU32StreamingResponse {
+message MonikerReadArrayU32Response {
   int32 status = 1;
   repeated uint32 array = 2;
 }
@@ -745,7 +745,7 @@ message BeginReadArrayU64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayU64StreamingResponse {
+message MonikerReadArrayU64Response {
   int32 status = 1;
   repeated uint64 array = 2;
 }
@@ -772,7 +772,7 @@ message BeginReadArrayU8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadArrayU8StreamingResponse {
+message MonikerReadArrayU8Response {
   int32 status = 1;
   repeated uint32 array = 2;
 }
@@ -797,7 +797,7 @@ message BeginReadBoolResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadBoolStreamingResponse {
+message MonikerReadBoolResponse {
   int32 status = 1;
   bool value = 2;
 }
@@ -822,7 +822,7 @@ message BeginReadDblResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadDblStreamingResponse {
+message MonikerReadDblResponse {
   int32 status = 1;
   double value = 2;
 }
@@ -990,7 +990,7 @@ message BeginReadI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadI16StreamingResponse {
+message MonikerReadI16Response {
   int32 status = 1;
   int32 value = 2;
 }
@@ -1015,7 +1015,7 @@ message BeginReadI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadI32StreamingResponse {
+message MonikerReadI32Response {
   int32 status = 1;
   int32 value = 2;
 }
@@ -1040,7 +1040,7 @@ message BeginReadI64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadI64StreamingResponse {
+message MonikerReadI64Response {
   int32 status = 1;
   int64 value = 2;
 }
@@ -1065,7 +1065,7 @@ message BeginReadI8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadI8StreamingResponse {
+message MonikerReadI8Response {
   int32 status = 1;
   int32 value = 2;
 }
@@ -1090,7 +1090,7 @@ message BeginReadSglResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadSglStreamingResponse {
+message MonikerReadSglResponse {
   int32 status = 1;
   float value = 2;
 }
@@ -1115,7 +1115,7 @@ message BeginReadU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadU16StreamingResponse {
+message MonikerReadU16Response {
   int32 status = 1;
   uint32 value = 2;
 }
@@ -1140,7 +1140,7 @@ message BeginReadU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadU32StreamingResponse {
+message MonikerReadU32Response {
   int32 status = 1;
   uint32 value = 2;
 }
@@ -1165,7 +1165,7 @@ message BeginReadU64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadU64StreamingResponse {
+message MonikerReadU64Response {
   int32 status = 1;
   uint64 value = 2;
 }
@@ -1190,7 +1190,7 @@ message BeginReadU8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message ReadU8StreamingResponse {
+message MonikerReadU8Response {
   int32 status = 1;
   uint32 value = 2;
 }
@@ -1340,11 +1340,11 @@ message BeginWriteArrayBoolResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayBoolStreamingRequest {
+message MonikerWriteArrayBoolRequest {
   repeated bool array = 1;
 }
 
-message WriteArrayBoolStreamingResponse {
+message MonikerWriteArrayBoolResponse {
   int32 status = 1;
 }
 
@@ -1368,11 +1368,11 @@ message BeginWriteArrayDblResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayDblStreamingRequest {
+message MonikerWriteArrayDblRequest {
   repeated double array = 1;
 }
 
-message WriteArrayDblStreamingResponse {
+message MonikerWriteArrayDblResponse {
   int32 status = 1;
 }
 
@@ -1396,11 +1396,11 @@ message BeginWriteArrayI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayI16StreamingRequest {
+message MonikerWriteArrayI16Request {
   repeated int32 array = 1;
 }
 
-message WriteArrayI16StreamingResponse {
+message MonikerWriteArrayI16Response {
   int32 status = 1;
 }
 
@@ -1424,11 +1424,11 @@ message BeginWriteArrayI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayI32StreamingRequest {
+message MonikerWriteArrayI32Request {
   repeated int32 array = 1;
 }
 
-message WriteArrayI32StreamingResponse {
+message MonikerWriteArrayI32Response {
   int32 status = 1;
 }
 
@@ -1452,11 +1452,11 @@ message BeginWriteArrayI64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayI64StreamingRequest {
+message MonikerWriteArrayI64Request {
   repeated int64 array = 1;
 }
 
-message WriteArrayI64StreamingResponse {
+message MonikerWriteArrayI64Response {
   int32 status = 1;
 }
 
@@ -1480,11 +1480,11 @@ message BeginWriteArrayI8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayI8StreamingRequest {
+message MonikerWriteArrayI8Request {
   repeated int32 array = 1;
 }
 
-message WriteArrayI8StreamingResponse {
+message MonikerWriteArrayI8Response {
   int32 status = 1;
 }
 
@@ -1508,11 +1508,11 @@ message BeginWriteArraySglResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArraySglStreamingRequest {
+message MonikerWriteArraySglRequest {
   repeated float array = 1;
 }
 
-message WriteArraySglStreamingResponse {
+message MonikerWriteArraySglResponse {
   int32 status = 1;
 }
 
@@ -1536,11 +1536,11 @@ message BeginWriteArrayU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayU16StreamingRequest {
+message MonikerWriteArrayU16Request {
   repeated uint32 array = 1;
 }
 
-message WriteArrayU16StreamingResponse {
+message MonikerWriteArrayU16Response {
   int32 status = 1;
 }
 
@@ -1564,11 +1564,11 @@ message BeginWriteArrayU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayU32StreamingRequest {
+message MonikerWriteArrayU32Request {
   repeated uint32 array = 1;
 }
 
-message WriteArrayU32StreamingResponse {
+message MonikerWriteArrayU32Response {
   int32 status = 1;
 }
 
@@ -1592,11 +1592,11 @@ message BeginWriteArrayU64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayU64StreamingRequest {
+message MonikerWriteArrayU64Request {
   repeated uint64 array = 1;
 }
 
-message WriteArrayU64StreamingResponse {
+message MonikerWriteArrayU64Response {
   int32 status = 1;
 }
 
@@ -1620,11 +1620,11 @@ message BeginWriteArrayU8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteArrayU8StreamingRequest {
+message MonikerWriteArrayU8Request {
   repeated uint32 array = 1;
 }
 
-message WriteArrayU8StreamingResponse {
+message MonikerWriteArrayU8Response {
   int32 status = 1;
 }
 
@@ -1648,11 +1648,11 @@ message BeginWriteBoolResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteBoolStreamingRequest {
+message MonikerWriteBoolRequest {
   bool value = 1;
 }
 
-message WriteBoolStreamingResponse {
+message MonikerWriteBoolResponse {
   int32 status = 1;
 }
 
@@ -1676,11 +1676,11 @@ message BeginWriteDblResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteDblStreamingRequest {
+message MonikerWriteDblRequest {
   double value = 1;
 }
 
-message WriteDblStreamingResponse {
+message MonikerWriteDblResponse {
   int32 status = 1;
 }
 
@@ -1836,11 +1836,11 @@ message BeginWriteI16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteI16StreamingRequest {
+message MonikerWriteI16Request {
   int32 value = 1;
 }
 
-message WriteI16StreamingResponse {
+message MonikerWriteI16Response {
   int32 status = 1;
 }
 
@@ -1864,11 +1864,11 @@ message BeginWriteI32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteI32StreamingRequest {
+message MonikerWriteI32Request {
   int32 value = 1;
 }
 
-message WriteI32StreamingResponse {
+message MonikerWriteI32Response {
   int32 status = 1;
 }
 
@@ -1892,11 +1892,11 @@ message BeginWriteI64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteI64StreamingRequest {
+message MonikerWriteI64Request {
   int64 value = 1;
 }
 
-message WriteI64StreamingResponse {
+message MonikerWriteI64Response {
   int32 status = 1;
 }
 
@@ -1920,11 +1920,11 @@ message BeginWriteI8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteI8StreamingRequest {
+message MonikerWriteI8Request {
   int32 value = 1;
 }
 
-message WriteI8StreamingResponse {
+message MonikerWriteI8Response {
   int32 status = 1;
 }
 
@@ -1948,11 +1948,11 @@ message BeginWriteSglResponse {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteSglStreamingRequest {
+message MonikerWriteSglRequest {
   float value = 1;
 }
 
-message WriteSglStreamingResponse {
+message MonikerWriteSglResponse {
   int32 status = 1;
 }
 
@@ -1976,11 +1976,11 @@ message BeginWriteU16Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteU16StreamingRequest {
+message MonikerWriteU16Request {
   uint32 value = 1;
 }
 
-message WriteU16StreamingResponse {
+message MonikerWriteU16Response {
   int32 status = 1;
 }
 
@@ -2004,11 +2004,11 @@ message BeginWriteU32Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteU32StreamingRequest {
+message MonikerWriteU32Request {
   uint32 value = 1;
 }
 
-message WriteU32StreamingResponse {
+message MonikerWriteU32Response {
   int32 status = 1;
 }
 
@@ -2032,11 +2032,11 @@ message BeginWriteU64Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteU64StreamingRequest {
+message MonikerWriteU64Request {
   uint64 value = 1;
 }
 
-message WriteU64StreamingResponse {
+message MonikerWriteU64Response {
   int32 status = 1;
 }
 
@@ -2060,11 +2060,11 @@ message BeginWriteU8Response {
   ni.data_monikers.Moniker moniker = 2;
 }
 
-message WriteU8StreamingRequest {
+message MonikerWriteU8Request {
   uint32 value = 1;
 }
 
-message WriteU8StreamingResponse {
+message MonikerWriteU8Response {
   int32 status = 1;
 }
 
diff --git a/generated/nifpga/nifpga_service.cpp b/generated/nifpga/nifpga_service.cpp
index 78671d3cc..ed37dca81 100644
--- a/generated/nifpga/nifpga_service.cpp
+++ b/generated/nifpga/nifpga_service.cpp
@@ -27,7 +27,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayBoolStreamingResponse response;
+     nifpga_grpc::MonikerReadArrayBoolResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -36,7 +36,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayDblStreamingResponse response;
+     nifpga_grpc::MonikerReadArrayDblResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -45,7 +45,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayI16StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayI16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -54,7 +54,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayI32StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayI32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -63,7 +63,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayI64StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayI64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -72,7 +72,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayI8StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayI8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -81,7 +81,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArraySglStreamingResponse response;
+     nifpga_grpc::MonikerReadArraySglResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -90,7 +90,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayU16StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayU16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -99,7 +99,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayU32StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayU32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -108,7 +108,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayU64StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayU64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -117,7 +117,7 @@ namespace nifpga_grpc {
      NiFpga_Session session;
      uint32_t indicator;
      size_t size;
-     nifpga_grpc::ReadArrayU8StreamingResponse response;
+     nifpga_grpc::MonikerReadArrayU8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -125,7 +125,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadBoolStreamingResponse response;
+     nifpga_grpc::MonikerReadBoolResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -133,7 +133,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadDblStreamingResponse response;
+     nifpga_grpc::MonikerReadDblResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -141,7 +141,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadI16StreamingResponse response;
+     nifpga_grpc::MonikerReadI16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -149,7 +149,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadI32StreamingResponse response;
+     nifpga_grpc::MonikerReadI32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -157,7 +157,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadI64StreamingResponse response;
+     nifpga_grpc::MonikerReadI64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -165,7 +165,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadI8StreamingResponse response;
+     nifpga_grpc::MonikerReadI8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -173,7 +173,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadSglStreamingResponse response;
+     nifpga_grpc::MonikerReadSglResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -181,7 +181,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadU16StreamingResponse response;
+     nifpga_grpc::MonikerReadU16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -189,7 +189,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadU32StreamingResponse response;
+     nifpga_grpc::MonikerReadU32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -197,7 +197,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadU64StreamingResponse response;
+     nifpga_grpc::MonikerReadU64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -205,7 +205,7 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t indicator;
-     nifpga_grpc::ReadU8StreamingResponse response;
+     nifpga_grpc::MonikerReadU8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -213,8 +213,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayBoolStreamingRequest request;
-     nifpga_grpc::WriteArrayBoolStreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayBoolRequest request;
+     nifpga_grpc::MonikerWriteArrayBoolResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -222,8 +222,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayDblStreamingRequest request;
-     nifpga_grpc::WriteArrayDblStreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayDblRequest request;
+     nifpga_grpc::MonikerWriteArrayDblResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -231,8 +231,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayI16StreamingRequest request;
-     nifpga_grpc::WriteArrayI16StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayI16Request request;
+     nifpga_grpc::MonikerWriteArrayI16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -240,8 +240,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayI32StreamingRequest request;
-     nifpga_grpc::WriteArrayI32StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayI32Request request;
+     nifpga_grpc::MonikerWriteArrayI32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -249,8 +249,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayI64StreamingRequest request;
-     nifpga_grpc::WriteArrayI64StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayI64Request request;
+     nifpga_grpc::MonikerWriteArrayI64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -258,8 +258,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayI8StreamingRequest request;
-     nifpga_grpc::WriteArrayI8StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayI8Request request;
+     nifpga_grpc::MonikerWriteArrayI8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -267,8 +267,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArraySglStreamingRequest request;
-     nifpga_grpc::WriteArraySglStreamingResponse response;
+     nifpga_grpc::MonikerWriteArraySglRequest request;
+     nifpga_grpc::MonikerWriteArraySglResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -276,8 +276,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayU16StreamingRequest request;
-     nifpga_grpc::WriteArrayU16StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayU16Request request;
+     nifpga_grpc::MonikerWriteArrayU16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -285,8 +285,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayU32StreamingRequest request;
-     nifpga_grpc::WriteArrayU32StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayU32Request request;
+     nifpga_grpc::MonikerWriteArrayU32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -294,8 +294,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayU64StreamingRequest request;
-     nifpga_grpc::WriteArrayU64StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayU64Request request;
+     nifpga_grpc::MonikerWriteArrayU64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -303,8 +303,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteArrayU8StreamingRequest request;
-     nifpga_grpc::WriteArrayU8StreamingResponse response;
+     nifpga_grpc::MonikerWriteArrayU8Request request;
+     nifpga_grpc::MonikerWriteArrayU8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -312,8 +312,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteBoolStreamingRequest request;
-     nifpga_grpc::WriteBoolStreamingResponse response;
+     nifpga_grpc::MonikerWriteBoolRequest request;
+     nifpga_grpc::MonikerWriteBoolResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -321,8 +321,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteDblStreamingRequest request;
-     nifpga_grpc::WriteDblStreamingResponse response;
+     nifpga_grpc::MonikerWriteDblRequest request;
+     nifpga_grpc::MonikerWriteDblResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -330,8 +330,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteI16StreamingRequest request;
-     nifpga_grpc::WriteI16StreamingResponse response;
+     nifpga_grpc::MonikerWriteI16Request request;
+     nifpga_grpc::MonikerWriteI16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -339,8 +339,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteI32StreamingRequest request;
-     nifpga_grpc::WriteI32StreamingResponse response;
+     nifpga_grpc::MonikerWriteI32Request request;
+     nifpga_grpc::MonikerWriteI32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -348,8 +348,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteI64StreamingRequest request;
-     nifpga_grpc::WriteI64StreamingResponse response;
+     nifpga_grpc::MonikerWriteI64Request request;
+     nifpga_grpc::MonikerWriteI64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -357,8 +357,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteI8StreamingRequest request;
-     nifpga_grpc::WriteI8StreamingResponse response;
+     nifpga_grpc::MonikerWriteI8Request request;
+     nifpga_grpc::MonikerWriteI8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -366,8 +366,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteSglStreamingRequest request;
-     nifpga_grpc::WriteSglStreamingResponse response;
+     nifpga_grpc::MonikerWriteSglRequest request;
+     nifpga_grpc::MonikerWriteSglResponse response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -375,8 +375,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteU16StreamingRequest request;
-     nifpga_grpc::WriteU16StreamingResponse response;
+     nifpga_grpc::MonikerWriteU16Request request;
+     nifpga_grpc::MonikerWriteU16Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -384,8 +384,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteU32StreamingRequest request;
-     nifpga_grpc::WriteU32StreamingResponse response;
+     nifpga_grpc::MonikerWriteU32Request request;
+     nifpga_grpc::MonikerWriteU32Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -393,8 +393,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteU64StreamingRequest request;
-     nifpga_grpc::WriteU64StreamingResponse response;
+     nifpga_grpc::MonikerWriteU64Request request;
+     nifpga_grpc::MonikerWriteU64Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
@@ -402,8 +402,8 @@ namespace nifpga_grpc {
   {
      NiFpga_Session session;
      uint32_t control;
-     nifpga_grpc::WriteU8StreamingRequest request;
-     nifpga_grpc::WriteU8StreamingResponse response;
+     nifpga_grpc::MonikerWriteU8Request request;
+     nifpga_grpc::MonikerWriteU8Response response;
      std::shared_ptr<NiFpgaLibraryInterface> library;
   };
 
diff --git a/source/codegen/common_helpers.py b/source/codegen/common_helpers.py
index fdb42bb64..8af239e75 100644
--- a/source/codegen/common_helpers.py
+++ b/source/codegen/common_helpers.py
@@ -1236,7 +1236,7 @@ def get_data_moniker_request_message_type(begin_function_name: str) -> str:
 
     Input expected is Begin* streaming API name.
     """
-    return f"{begin_function_name.replace('Begin', '')}StreamingRequest"
+    return f"{begin_function_name.replace('Begin', 'Moniker')}Request"
 
 
 def get_data_moniker_response_message_type(begin_function_name: str) -> str:
@@ -1244,7 +1244,7 @@ def get_data_moniker_response_message_type(begin_function_name: str) -> str:
 
     Input expected is Begin* streaming API name.
     """
-    return f"{begin_function_name.replace('Begin', '')}StreamingResponse"
+    return f"{begin_function_name.replace('Begin', 'Moniker')}Response"
 
 
 def get_data_moniker_function_parameters(function: dict) -> Tuple[List[dict], List[dict]]:
diff --git a/source/codegen/metadata/nidaqmx/functions.py b/source/codegen/metadata/nidaqmx/functions.py
index 13867797c..ec89562b3 100644
--- a/source/codegen/metadata/nidaqmx/functions.py
+++ b/source/codegen/metadata/nidaqmx/functions.py
@@ -17612,9 +17612,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -17765,9 +17766,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -17864,9 +17866,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -17964,9 +17967,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18063,9 +18067,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18151,9 +18156,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18250,9 +18256,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18444,9 +18451,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18543,9 +18551,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -18618,8 +18627,10 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayFrequency',
                 'python_data_type': 'float',
                 'python_type_annotation': 'List[float]',
@@ -18632,8 +18643,10 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayDutyCycle',
                 'python_data_type': 'float',
                 'python_type_annotation': 'List[float]',
@@ -18652,7 +18665,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -18676,6 +18691,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadCtrFreqScalar': {
@@ -18704,7 +18720,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'frequency',
                 'python_data_type': 'float',
                 'python_type_annotation': 'float',
@@ -18713,7 +18731,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'dutyCycle',
                 'python_data_type': 'float',
                 'python_type_annotation': 'float',
@@ -18734,7 +18754,8 @@
             }
         ],
         'python_codegen_method': 'CustomCode',
-        'returns': 'int32'
+        'returns': 'int32',
+        'supports_streaming': True
     },
     'ReadCtrTicks': {
         'calling_convention': 'StdCall',
@@ -18783,8 +18804,10 @@
             {
                 'ctypes_data_type': 'numpy.uint32',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayU32Data',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayHighTicks',
                 'python_data_type': 'int',
                 'python_type_annotation': 'List[int]',
@@ -18797,8 +18820,10 @@
             {
                 'ctypes_data_type': 'numpy.uint32',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayU32Data',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayLowTicks',
                 'python_data_type': 'int',
                 'python_type_annotation': 'List[int]',
@@ -18817,7 +18842,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -18841,6 +18868,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadCtrTicksScalar': {
@@ -18869,6 +18897,8 @@
             {
                 'ctypes_data_type': 'ctypes.c_uint32',
                 'direction': 'out',
+                'grpc_streaming_type': 'U32Data',
+                'is_streaming_type': True,
                 'name': 'highTicks',
                 'python_data_type': 'int',
                 'type': 'uInt32'
@@ -18876,6 +18906,8 @@
             {
                 'ctypes_data_type': 'ctypes.c_uint32',
                 'direction': 'out',
+                'grpc_streaming_type': 'U32Data',
+                'is_streaming_type': True,
                 'name': 'lowTicks',
                 'python_data_type': 'int',
                 'type': 'uInt32'
@@ -18895,7 +18927,8 @@
             }
         ],
         'python_codegen_method': 'CustomCode',
-        'returns': 'int32'
+        'returns': 'int32',
+        'supports_streaming': True
     },
     'ReadCtrTime': {
         'calling_convention': 'StdCall',
@@ -18944,8 +18977,10 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayHighTime',
                 'python_data_type': 'float',
                 'python_type_annotation': 'List[float]',
@@ -18958,8 +18993,10 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArrayLowTime',
                 'python_data_type': 'float',
                 'python_type_annotation': 'List[float]',
@@ -18978,7 +19015,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19002,6 +19041,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadCtrTimeScalar': {
@@ -19030,7 +19070,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'highTime',
                 'python_data_type': 'float',
                 'python_type_annotation': 'float',
@@ -19039,7 +19081,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'lowTime',
                 'python_data_type': 'float',
                 'python_type_annotation': 'float',
@@ -19060,7 +19104,8 @@
             }
         ],
         'python_codegen_method': 'CustomCode',
-        'returns': 'int32'
+        'returns': 'int32',
+        'supports_streaming': True
     },
     'ReadDigitalLines': {
         'calling_convention': 'StdCall',
@@ -19109,9 +19154,11 @@
             {
                 'ctypes_data_type': 'numpy.bool',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayU8Data',
                 'has_explicit_buffer_size': True,
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArray',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19131,7 +19178,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19165,6 +19214,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadDigitalScalarU32': {
@@ -19292,9 +19342,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -19391,9 +19442,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanRead',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -19466,9 +19518,11 @@
             {
                 'ctypes_data_type': 'numpy.uint8',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayU8Data',
                 'has_explicit_buffer_size': True,
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArray',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19488,7 +19542,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19512,6 +19568,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadPowerBinaryI16': {
@@ -19562,7 +19619,9 @@
                 'coerced': True,
                 'ctypes_data_type': 'numpy.generic',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayI16Data',
                 'is_list': True,
+                'is_streaming_type': True,
                 'name': 'readArrayVoltage',
                 'python_data_type': 'object',
                 'size': {
@@ -19575,7 +19634,9 @@
                 'coerced': True,
                 'ctypes_data_type': 'numpy.generic',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayI16Data',
                 'is_list': True,
+                'is_streaming_type': True,
                 'name': 'readArrayCurrent',
                 'python_data_type': 'object',
                 'size': {
@@ -19594,7 +19655,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19618,6 +19681,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadPowerF64': {
@@ -19667,7 +19731,9 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
+                'is_streaming_type': True,
                 'name': 'readArrayVoltage',
                 'python_data_type': 'float',
                 'size': {
@@ -19679,7 +19745,9 @@
             {
                 'ctypes_data_type': 'numpy.float64',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayDoubleData',
                 'is_list': True,
+                'is_streaming_type': True,
                 'name': 'readArrayCurrent',
                 'python_data_type': 'float',
                 'size': {
@@ -19698,7 +19766,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsPerChanRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19722,6 +19792,7 @@
         ],
         'python_codegen_method': 'CustomCode',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'ReadPowerScalarF64': {
@@ -19750,7 +19821,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'voltage',
                 'python_data_type': 'float',
                 'python_description': '',
@@ -19760,7 +19833,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_double',
                 'direction': 'out',
+                'grpc_streaming_type': 'DoubleData',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'current',
                 'python_data_type': 'float',
                 'python_description': '',
@@ -19782,7 +19857,8 @@
             }
         ],
         'python_codegen_method': 'CustomCode',
-        'returns': 'int32'
+        'returns': 'int32',
+        'supports_streaming': True
     },
     'ReadRaw': {
         'calling_convention': 'StdCall',
@@ -19820,9 +19896,11 @@
             {
                 'ctypes_data_type': 'numpy.generic',
                 'direction': 'out',
+                'grpc_streaming_type': 'ArrayU8Data',
                 'has_explicit_buffer_size': True,
                 'is_list': True,
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'readArray',
                 'python_data_type': 'dynamic',
                 'python_description': '',
@@ -19841,7 +19919,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'sampsRead',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19852,7 +19932,9 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
+                'is_streaming_type': True,
                 'name': 'numBytesPerSamp',
                 'python_data_type': 'int',
                 'python_description': '',
@@ -19875,6 +19957,7 @@
         ],
         'python_codegen_method': 'no',
         'returns': 'int32',
+        'supports_streaming': True,
         'timeout_error': 'DAQmxErrorSamplesNotYetAvailable'
     },
     'RegisterDoneEvent': {
@@ -24146,9 +24229,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -24307,9 +24391,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -24404,9 +24489,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -24502,9 +24588,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -24599,9 +24686,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -25359,9 +25447,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
@@ -25456,9 +25545,10 @@
             {
                 'ctypes_data_type': 'ctypes.c_int',
                 'direction': 'out',
+                'grpc_streaming_type': 'I32Data',
                 'is_optional_in_python': False,
-                'name': 'sampsPerChanWritten',
                 'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
                 'python_data_type': 'int',
                 'python_description': '',
                 'python_type_annotation': 'int',
diff --git a/source/codegen/templates/service_helpers.mako b/source/codegen/templates/service_helpers.mako
index 666f52e88..25acbabc3 100644
--- a/source/codegen/templates/service_helpers.mako
+++ b/source/codegen/templates/service_helpers.mako
@@ -459,8 +459,13 @@ ${set_response_values(output_parameters=output_parameters, init_method=false)}\
   grpc_field_name = common_helpers.get_grpc_field_name(param)
   size_param_name = service_helpers.get_size_param_name(param)
 %>\
+% if common_helpers.is_string_arg(param):
+      data->response.mutable_${grpc_field_name}()->reserve(request->${size_param_name}());
+      data->response.mutable_${grpc_field_name}()->resize(request->${size_param_name}(), 0);
+% else:
       data->response.mutable_${grpc_field_name}()->Reserve(request->${size_param_name}());
       data->response.mutable_${grpc_field_name}()->Resize(request->${size_param_name}(), 0);
+% endif
 % endfor
 </%def>
 
diff --git a/source/tests/integration/ni_fake_fpga_streaming_tests.cpp b/source/tests/integration/ni_fake_fpga_streaming_tests.cpp
index 6382a101f..99d8f4edf 100644
--- a/source/tests/integration/ni_fake_fpga_streaming_tests.cpp
+++ b/source/tests/integration/ni_fake_fpga_streaming_tests.cpp
@@ -1,21 +1,22 @@
-#include <gtest/gtest.h>
-#include "../generated/nifpga/nifpga_client.h"
-#include <nifpga.grpc.pb.h>
+#include <../generated/nifpga/nifpga_mock_library.h>
+#include <NiFpga.h>
+#include <gmock/gmock-spec-builders.h>
 #include <google/protobuf/stubs/port.h>
-#include <grpcpp/server_builder.h>
 #include <grpcpp/client_context.h>
-#include <register_all_services.h>
-#include <NiFpga.h>
-#include <server/session_resource_repository.h>
-#include <../generated/nifpga/nifpga_mock_library.h>
+#include <grpcpp/server_builder.h>
+#include <gtest/gtest.h>
+#include <nifpga.grpc.pb.h>
+#include <nifpga.pb.h>
 #include <nifpga/nifpga_service.h>
+#include <register_all_services.h>
 #include <server/data_moniker_service.h>
+#include <server/session_resource_repository.h>
 #include <sideband_grpc.h>
-#include <nifpga.pb.h>
-#include <nifpga.grpc.pb.h>
-#include <gmock/gmock-spec-builders.h>
+
 #include <thread>
 
+#include "../generated/nifpga/nifpga_client.h"
+
 namespace ni {
 namespace tests {
 namespace integration {
@@ -42,22 +43,22 @@ class NiFakeFpgaStreamingTests : public ::testing::Test {
   std::atomic<bool> shutdown_{false};
 
  public:
-    NiFakeFpgaStreamingTests()
-    {
-        session_repository_ = std::make_shared<nidevice_grpc::SessionRepository>();
-        library_ = std::make_shared<ni::tests::unit::NiFpgaMockLibrary>();
-        auto ni_fpga_session_repository = std::make_shared<nidevice_grpc::SessionResourceRepository<NiFpga_Session>>(session_repository_);
-        fpgaService_ = std::make_shared<nifpga_grpc::NiFpgaService>(library_, ni_fpga_session_repository, FeatureToggles({}, CodeReadiness::kNextRelease));
-        moniker_service_ = std::make_shared<ni::data_monikers::DataMonikerService>();
-        server_ = start_server();
-        nifpga_grpc::RegisterMonikerEndpoints();
-        stub_ = nifpga_grpc::NiFpga::NewStub(server_->InProcessChannel(::grpc::ChannelArguments()));
-        moniker_service_stub_ = ni::data_monikers::DataMoniker::NewStub(server_->InProcessChannel(::grpc::ChannelArguments()));
-        Mock::AllowLeak(library_.get());
-
-        // TODO: Implement sideband socket thread when we could support testing sideband streaming inprocess
-        // sideband_socket_thread_ = new std::thread(RunSidebandSocketsAccept, "localhost", 50055);
-    }
+  NiFakeFpgaStreamingTests()
+  {
+    session_repository_ = std::make_shared<nidevice_grpc::SessionRepository>();
+    library_ = std::make_shared<ni::tests::unit::NiFpgaMockLibrary>();
+    auto ni_fpga_session_repository = std::make_shared<nidevice_grpc::SessionResourceRepository<NiFpga_Session>>(session_repository_);
+    fpgaService_ = std::make_shared<nifpga_grpc::NiFpgaService>(library_, ni_fpga_session_repository, FeatureToggles({}, CodeReadiness::kNextRelease));
+    moniker_service_ = std::make_shared<ni::data_monikers::DataMonikerService>();
+    server_ = start_server();
+    nifpga_grpc::RegisterMonikerEndpoints();
+    stub_ = nifpga_grpc::NiFpga::NewStub(server_->InProcessChannel(::grpc::ChannelArguments()));
+    moniker_service_stub_ = ni::data_monikers::DataMoniker::NewStub(server_->InProcessChannel(::grpc::ChannelArguments()));
+    Mock::AllowLeak(library_.get());
+
+    // TODO: Implement sideband socket thread when we could support testing sideband streaming inprocess
+    // sideband_socket_thread_ = new std::thread(RunSidebandSocketsAccept, "localhost", 50055);
+  }
 
   virtual ~NiFakeFpgaStreamingTests()
   {
@@ -87,7 +88,6 @@ class NiFakeFpgaStreamingTests : public ::testing::Test {
     return library_;
   }
 
-
   std::unique_ptr<::grpc::Server> start_server()
   {
     ::grpc::ServerBuilder builder;
@@ -130,11 +130,10 @@ TEST_F(NiFakeFpgaStreamingTests, StreamRead_scalar)
 
   auto stream = moniker_stub().get()->StreamRead(&moniker_context, read_requests);
 
-  for (int i = 0; i < 5; i++)
-  {
+  for (int i = 0; i < 5; i++) {
     // Read data
-    nifpga_grpc::ReadI32StreamingResponse read_value_i32;
-    nifpga_grpc::ReadI64StreamingResponse read_value_i64;
+    nifpga_grpc::MonikerReadI32Response read_value_i32;
+    nifpga_grpc::MonikerReadI64Response read_value_i64;
 
     ni::data_monikers::MonikerReadResponse read_result;
     stream->Read(&read_result);
@@ -171,7 +170,6 @@ TEST_F(NiFakeFpgaStreamingTests, StreamRead_Array)
   auto begin_read_i64_response = nifpga_grpc::experimental::client::begin_read_array_i64(stub(), *session, 0, 9);
   auto read_moniker_i64 = new ni::data_monikers::Moniker(begin_read_i64_response.moniker());
 
-
   grpc::ClientContext moniker_context;
   ni::data_monikers::MonikerList read_requests;
   read_requests.mutable_read_monikers()->AddAllocated(read_moniker_i32);
@@ -181,8 +179,8 @@ TEST_F(NiFakeFpgaStreamingTests, StreamRead_Array)
 
   for (int i = 0; i < 5; i++) {
     // Read data
-    nifpga_grpc::ReadArrayI32StreamingResponse read_values_i32;
-    nifpga_grpc::ReadArrayI64StreamingResponse read_values_i64;
+    nifpga_grpc::MonikerReadArrayI32Response read_values_i32;
+    nifpga_grpc::MonikerReadArrayI64Response read_values_i64;
 
     ni::data_monikers::MonikerReadResponse read_result;
     stream->Read(&read_result);
@@ -199,7 +197,7 @@ TEST_F(NiFakeFpgaStreamingTests, StreamRead_Array)
 }
 
 TEST_F(NiFakeFpgaStreamingTests, StreamWrite_Array)
-{   
+{
   // create some setup for writing
   auto session = std::make_unique<nidevice_grpc::Session>();
   std::vector<pb::int32> data_int_i32 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
@@ -227,7 +225,6 @@ TEST_F(NiFakeFpgaStreamingTests, StreamWrite_Array)
   write_request.mutable_monikers()->mutable_write_monikers()->AddAllocated(write_moniker_i32);
   write_request.mutable_monikers()->mutable_write_monikers()->AddAllocated(write_moniker_i64);
 
-
   auto write_stream = moniker_stub().get()->StreamWrite(&moniker_context);
   write_stream->Write(write_request);
 
@@ -244,7 +241,6 @@ TEST_F(NiFakeFpgaStreamingTests, StreamWrite_Array)
     write_data_request.mutable_data()->add_values()->PackFrom(write_values_array_i64);
 
     write_stream->Write(write_data_request);
- 
   }
 
   write_stream->WritesDone();
@@ -264,7 +260,7 @@ TEST_F(NiFakeFpgaStreamingTests, StreamReadWrite_Array)
 
   // Set expectation on the mocked fpga lib method.
   EXPECT_CALL(*library(), WriteArrayI32(_, control, _, write_size_i32))
-      .With(Args<2,3>(ElementsAreArray(write_data_int32)))
+      .With(Args<2, 3>(ElementsAreArray(write_data_int32)))
       .WillRepeatedly(::testing::Return(0));
   EXPECT_CALL(*library(), WriteArrayI64(_, control, _, write_size_i64))
       .With(Args<2, 3>(ElementsAreArray(write_data_int64)))
@@ -288,7 +284,7 @@ TEST_F(NiFakeFpgaStreamingTests, StreamReadWrite_Array)
   auto begin_write_i64_response = nifpga_grpc::experimental::client::begin_write_array_i64(stub(), *session, control);
   auto write_moniker_i64 = new ni::data_monikers::Moniker(begin_write_i64_response.moniker());
 
-    // Dont worry about deleting read_moniker_i32 and read_moniker_i64 since AddAllocated takes ownership of the ptr being passed in ensuring its destruction.
+  // Dont worry about deleting read_moniker_i32 and read_moniker_i64 since AddAllocated takes ownership of the ptr being passed in ensuring its destruction.
   auto begin_read_i32_array__response = nifpga_grpc::experimental::client::begin_read_array_i32(stub(), *session, 0, read_data_int32.size());
   auto read_moniker_i32 = new ni::data_monikers::Moniker(begin_read_i32_array__response.moniker());
   auto begin_read_i64_response = nifpga_grpc::experimental::client::begin_read_array_i64(stub(), *session, 0, read_data_int64.size());
@@ -301,7 +297,6 @@ TEST_F(NiFakeFpgaStreamingTests, StreamReadWrite_Array)
   write_request.mutable_monikers()->mutable_write_monikers()->AddAllocated(write_moniker_i32);
   write_request.mutable_monikers()->mutable_write_monikers()->AddAllocated(write_moniker_i64);
 
-
   auto write_stream = moniker_stub().get()->StreamReadWrite(&moniker_context);
   write_stream->Write(write_request);
 
@@ -319,8 +314,8 @@ TEST_F(NiFakeFpgaStreamingTests, StreamReadWrite_Array)
 
     write_stream->Write(write_data_request);
 
-    nifpga_grpc::ReadArrayI32StreamingResponse read_values_i32;
-    nifpga_grpc::ReadArrayI64StreamingResponse read_values_i64;
+    nifpga_grpc::MonikerReadArrayI32Response read_values_i32;
+    nifpga_grpc::MonikerReadArrayI64Response read_values_i64;
 
     ni::data_monikers::MonikerReadResponse read_result;
     write_stream->Read(&read_result);
@@ -405,8 +400,8 @@ TEST_F(NiFakeFpgaStreamingTests, DISABLED_SidebandStreamReadWrite_Array)
 
     WriteSidebandMessage(sideband_token, write_data_request);
 
-    nifpga_grpc::ReadArrayI32StreamingResponse read_values_i32;
-    nifpga_grpc::ReadArrayI64StreamingResponse read_values_i64;
+    nifpga_grpc::MonikerReadArrayI32Response read_values_i32;
+    nifpga_grpc::MonikerReadArrayI64Response read_values_i64;
 
     ni::data_monikers::SidebandReadResponse read_result;
     ReadSidebandMessage(sideband_token, &read_result);