diff --git a/Source/chronicle/lib/chronicle/constraints.ex b/Source/chronicle/lib/chronicle/constraints.ex
index 9946d09..35d674f 100644
--- a/Source/chronicle/lib/chronicle/constraints.ex
+++ b/Source/chronicle/lib/chronicle/constraints.ex
@@ -55,10 +55,10 @@ defmodule Chronicle.Constraints do
     definitions =
       Enum.map(constraints, &build_constraint/1)
 
-    request = %RegisterConstraintsRequest{
+    request = struct(RegisterConstraintsRequest,
       EventStore: event_store,
       Constraints: definitions
-    }
+    )
 
     case Constraints.Stub.register(channel, request) do
       {:ok, _} -> :ok
@@ -67,21 +67,21 @@ defmodule Chronicle.Constraints do
   end
 
   defp build_constraint(%{type: :unique, name: name, event_type_id: event_type_id, on: properties}) do
-    %Constraint{
+    struct(Constraint,
       Name: name,
       Type: :Unique,
-      Definition: %OneOf_UniqueConstraintDefinition_UniqueEventTypeConstraintDefinition{
-        Value0: %UniqueConstraintDefinition{
+      Definition: struct(OneOf_UniqueConstraintDefinition_UniqueEventTypeConstraintDefinition,
+        Value0: struct(UniqueConstraintDefinition,
           EventDefinitions: [
-            %UniqueConstraintEventDefinition{
+            struct(UniqueConstraintEventDefinition,
               EventTypeId: event_type_id,
               Properties: List.wrap(properties)
-            }
+            )
           ],
           IgnoreCasing: false
-        }
-      }
-    }
+        )
+      )
+    )
   end
 
   defp build_constraint(%{type: :unique, name: name, event_type: event_module} = constraint) do
diff --git a/Source/chronicle/lib/chronicle/event_log.ex b/Source/chronicle/lib/chronicle/event_log.ex
index a294cc6..d23683b 100644
--- a/Source/chronicle/lib/chronicle/event_log.ex
+++ b/Source/chronicle/lib/chronicle/event_log.ex
@@ -70,8 +70,8 @@ defmodule Chronicle.EventLog do
       namespace = Keyword.get(opts, :namespace, config.namespace)
       event_module = event.__struct__
 
-      request = %AppendRequest{
-        CorrelationId: %BclGuid{},
+      request = struct(AppendRequest,
+        CorrelationId: struct(BclGuid),
         EventStore: config.event_store,
         Namespace: namespace,
         EventSequenceId: @event_log_id,
@@ -79,18 +79,18 @@ defmodule Chronicle.EventLog do
         EventSourceId: event_source_id,
         EventStreamType: Keyword.get(opts, :event_stream_type, "All"),
         EventStreamId: Keyword.get(opts, :event_stream_id, "Default"),
-        EventType: %EventType{
+        EventType: struct(EventType,
           Id: event_module.__chronicle_event_type__(:id),
           Generation: event_module.__chronicle_event_type__(:generation)
-        },
+        ),
         Content: encode_event(event),
         Causation: [client_causation()],
-        CausedBy: %Identity{Subject: "elixir-client", Name: "Chronicle Elixir Client", UserName: "chronicle"},
-        ConcurrencyScope: %ConcurrencyScope{SequenceNumber: 18_446_744_073_709_551_615},
+        CausedBy: struct(Identity, Subject: "elixir-client", Name: "Chronicle Elixir Client", UserName: "chronicle"),
+        ConcurrencyScope: struct(ConcurrencyScope, SequenceNumber: 18_446_744_073_709_551_615),
         Occurred: current_datetime_offset(),
         Tags: Keyword.get(opts, :tags, []),
         Subject: Keyword.get(opts, :subject, "")
-      }
+      )
 
       case EventSequences.Stub.append(channel, request) do
         {:ok, response} ->
@@ -128,26 +128,26 @@ defmodule Chronicle.EventLog do
         Enum.map(events, fn event ->
           module = event.__struct__
 
-          %EventToAppend{
+          struct(EventToAppend,
             EventSourceType: Keyword.get(opts, :event_source_type, "Default"),
             EventSourceId: event_source_id,
             EventStreamType: Keyword.get(opts, :event_stream_type, "All"),
             EventStreamId: Keyword.get(opts, :event_stream_id, "Default"),
-            EventType: %EventType{
+            EventType: struct(EventType,
               Id: module.__chronicle_event_type__(:id),
               Generation: module.__chronicle_event_type__(:generation)
-            },
+            ),
             Content: encode_event(event),
             Tags: Keyword.get(opts, :tags, [])
-          }
+          )
         end)
 
-      request = %AppendManyRequest{
+      request = struct(AppendManyRequest,
         EventStore: config.event_store,
         Namespace: namespace,
         EventSequenceId: @event_log_id,
         Events: event_entries
-      }
+      )
 
       case EventSequences.Stub.append_many(channel, request) do
         {:ok, response} ->
@@ -185,19 +185,19 @@ defmodule Chronicle.EventLog do
 
       event_types =
         Enum.map(event_type_modules, fn module ->
-          %EventType{
+          struct(EventType,
             Id: module.__chronicle_event_type__(:id),
             Generation: module.__chronicle_event_type__(:generation)
-          }
+          )
         end)
 
-      request = %GetForEventSourceIdAndEventTypesRequest{
+      request = struct(GetForEventSourceIdAndEventTypesRequest,
         EventStore: config.event_store,
         Namespace: namespace,
         EventSequenceId: @event_log_id,
         EventSourceId: event_source_id,
         EventTypes: event_types
-      }
+      )
 
       case EventSequences.Stub.get_for_event_source_id_and_event_types(channel, request) do
         {:ok, response} -> {:ok, Map.get(response, :Events, [])}
@@ -235,13 +235,13 @@ defmodule Chronicle.EventLog do
   end
 
   defp client_causation do
-    %Causation{
+    struct(Causation,
       Type: "Elixir.Chronicle.Client",
       Occurred: current_datetime_offset()
-    }
+    )
   end
 
   defp current_datetime_offset do
-    %SerializableDateTimeOffset{Value: DateTime.utc_now() |> DateTime.to_iso8601()}
+    struct(SerializableDateTimeOffset, Value: DateTime.utc_now() |> DateTime.to_iso8601())
   end
 end
diff --git a/Source/chronicle/lib/chronicle/event_types.ex b/Source/chronicle/lib/chronicle/event_types.ex
index 3665887..d06699a 100644
--- a/Source/chronicle/lib/chronicle/event_types.ex
+++ b/Source/chronicle/lib/chronicle/event_types.ex
@@ -35,21 +35,21 @@ defmodule Chronicle.EventTypes do
   def register(channel, event_store, event_type_modules) when is_list(event_type_modules) do
     registrations =
       Enum.map(event_type_modules, fn module ->
-        %EventTypeRegistration{
-          Type: %EventType{
+        struct(EventTypeRegistration,
+          Type: struct(EventType,
             Id: module.__chronicle_event_type__(:id),
             Generation: module.__chronicle_event_type__(:generation)
-          },
+          ),
           Schema: generate_schema(module),
           EventStore: event_store
-        }
+        )
       end)
 
-    request = %RegisterEventTypesRequest{
+    request = struct(RegisterEventTypesRequest,
       EventStore: event_store,
       Types: registrations,
       DisableValidation: false
-    }
+    )
 
     case EventTypes.Stub.register(channel, request) do
       {:ok, _} -> :ok
diff --git a/Source/chronicle/lib/chronicle/projections/registrar.ex b/Source/chronicle/lib/chronicle/projections/registrar.ex
index f9053b2..a743bcc 100644
--- a/Source/chronicle/lib/chronicle/projections/registrar.ex
+++ b/Source/chronicle/lib/chronicle/projections/registrar.ex
@@ -44,7 +44,7 @@ defmodule Chronicle.Projections.Registrar do
 
   # MongoDB sink type ID: "22202c41-2be1-4547-9c00-f0b1f797fd75"
   # Computed from .NET Guid.ToByteArray() split into lo/hi fixed64 little-endian
-  @mongodb_sink_type_id %BclGuid{lo: 0x45472BE122202C41, hi: 0x75FD97F7B1F0009C}
+  defp mongodb_sink_type_id, do: struct(BclGuid, lo: 0x45472BE122202C41, hi: 0x75FD97F7B1F0009C)
 
   @retry_delay 5_000
 
@@ -116,14 +116,14 @@ defmodule Chronicle.Projections.Registrar do
   end
 
   defp ensure_event_store(channel, event_store) do
-    case EventStores.Stub.ensure(channel, %EnsureEventStore{Name: event_store}) do
+    case EventStores.Stub.ensure(channel, struct(EnsureEventStore, Name: event_store)) do
       {:ok, _} -> :ok
       {:error, reason} -> {:error, {:ensure_event_store, reason}}
     end
   end
 
   defp ensure_namespace(channel, event_store, namespace) do
-    case Namespaces.Stub.ensure(channel, %EnsureNamespace{EventStore: event_store, Name: namespace}) do
+    case Namespaces.Stub.ensure(channel, struct(EnsureNamespace, EventStore: event_store, Name: namespace)) do
       {:ok, _} -> :ok
       {:error, reason} -> {:error, {:ensure_namespace, reason}}
     end
@@ -136,17 +136,17 @@ defmodule Chronicle.Projections.Registrar do
       |> Enum.map(fn rm ->
         model_id = rm.__chronicle_read_model__(:id)
 
-        %ReadModelDefinition{
-          Type: %ReadModelType{Identifier: model_id, Generation: 1},
+        struct(ReadModelDefinition,
+          Type: struct(ReadModelType, Identifier: model_id, Generation: 1),
           ContainerName: model_id,
           DisplayName: model_id,
-          Sink: %SinkDefinition{ConfigurationId: %BclGuid{}, TypeId: @mongodb_sink_type_id},
+          Sink: struct(SinkDefinition, ConfigurationId: struct(BclGuid), TypeId: mongodb_sink_type_id()),
           Schema: generate_read_model_schema(rm),
           ObserverType: 2,
           ObserverIdentifier: model_id,
           Owner: 2,
           Source: 1
-        }
+        )
       end)
 
     reducer_definitions =
@@ -156,17 +156,17 @@ defmodule Chronicle.Projections.Registrar do
         model_id = model_module.__chronicle_read_model__(:id)
         reducer_id = reducer_module.__chronicle_reducer__(:id)
 
-        %ReadModelDefinition{
-          Type: %ReadModelType{Identifier: model_id, Generation: 1},
+        struct(ReadModelDefinition,
+          Type: struct(ReadModelType, Identifier: model_id, Generation: 1),
           ContainerName: model_id,
           DisplayName: model_id,
-          Sink: %SinkDefinition{ConfigurationId: %BclGuid{}, TypeId: @mongodb_sink_type_id},
+          Sink: struct(SinkDefinition, ConfigurationId: struct(BclGuid), TypeId: mongodb_sink_type_id()),
           Schema: generate_read_model_schema(model_module),
           ObserverType: 1,
           ObserverIdentifier: reducer_id,
           Owner: 2,
           Source: 1
-        }
+        )
       end)
 
     all_definitions = projection_definitions ++ reducer_definitions
@@ -174,12 +174,12 @@ defmodule Chronicle.Projections.Registrar do
     if Enum.empty?(all_definitions) do
       :ok
     else
-      request = %RegisterManyRequest{
+      request = struct(RegisterManyRequest,
         EventStore: state.event_store,
         Owner: 2,
         ReadModels: all_definitions,
         Source: 1
-      }
+      )
 
       case ReadModels.Stub.register_many(channel, request) do
         {:ok, _} -> :ok
@@ -238,11 +238,11 @@ defmodule Chronicle.Projections.Registrar do
     else
       definitions = Enum.map(projection_read_models, &build_projection_definition(&1))
 
-      request = %RegisterRequest{
+      request = struct(RegisterRequest,
         EventStore: state.event_store,
         Owner: 1,
         Projections: definitions
-      }
+      )
 
       case Projections.Stub.register(channel, request) do
         {:ok, _} ->
@@ -266,14 +266,14 @@ defmodule Chronicle.Projections.Registrar do
         key = Keyword.get(opts, :key, "$eventSourceId")
         parent_key = Keyword.get(opts, :parent_key, "")
 
-        %KeyValuePair_EventType_FromDefinition{
+        struct(KeyValuePair_EventType_FromDefinition,
           Key: proto_event_type(event_module),
-          Value: %FromDefinition{
+          Value: struct(FromDefinition,
             Key: key,
             Properties: properties,
             ParentKey: parent_key
-          }
-        }
+          )
+        )
       end)
 
     join_entries =
@@ -283,14 +283,14 @@ defmodule Chronicle.Projections.Registrar do
         key = Keyword.get(opts, :key, "$eventSourceId")
         on = Keyword.fetch!(opts, :on)
 
-        %KeyValuePair_EventType_JoinDefinition{
+        struct(KeyValuePair_EventType_JoinDefinition,
           Key: proto_event_type(event_module),
-          Value: %JoinDefinition{
+          Value: struct(JoinDefinition,
             On: on,
             Key: key,
             Properties: properties
-          }
-        }
+          )
+        )
       end)
 
     removed_with_entries =
@@ -299,10 +299,10 @@ defmodule Chronicle.Projections.Registrar do
         key = Keyword.get(opts, :key, "$eventSourceId")
         parent_key = Keyword.get(opts, :parent_key, "")
 
-        %KeyValuePair_EventType_RemovedWithDefinition{
+        struct(KeyValuePair_EventType_RemovedWithDefinition,
           Key: proto_event_type(event_module),
-          Value: %RemovedWithDefinition{Key: key, ParentKey: parent_key}
-        }
+          Value: struct(RemovedWithDefinition, Key: key, ParentKey: parent_key)
+        )
       end)
 
     from_every =
@@ -311,13 +311,13 @@ defmodule Chronicle.Projections.Registrar do
           nil
 
         [opts | _] ->
-          %FromEveryDefinition{
+          struct(FromEveryDefinition,
             Properties: build_properties(opts),
             IncludeChildren: Keyword.get(opts, :include_children, false)
-          }
+          )
       end
 
-    %ProjectionDefinition{
+    struct(ProjectionDefinition,
       Identifier: identifier,
       ReadModel: model_name,
       EventSequenceId: "event-log",
@@ -328,7 +328,7 @@ defmodule Chronicle.Projections.Registrar do
       RemovedWith: removed_with_entries,
       All: from_every,
       InitialModelState: initial_model_state(read_model_module)
-    }
+    )
   end
 
   # Converts set/add/subtract/count opts into a Chronicle properties map.
@@ -378,9 +378,9 @@ defmodule Chronicle.Projections.Registrar do
   defp resolve_expression(str) when is_binary(str), do: str
 
   defp proto_event_type(event_module) do
-    %ProtoEventType{
+    struct(ProtoEventType,
       Id: event_module.__chronicle_event_type__(:id),
       Generation: event_module.__chronicle_event_type__(:generation)
-    }
+    )
   end
 end
diff --git a/Source/chronicle/lib/chronicle/reactors/handler.ex b/Source/chronicle/lib/chronicle/reactors/handler.ex
index b8f0ed5..89db471 100644
--- a/Source/chronicle/lib/chronicle/reactors/handler.ex
+++ b/Source/chronicle/lib/chronicle/reactors/handler.ex
@@ -103,17 +103,17 @@ defmodule Chronicle.Reactors.Handler do
         event -> Map.get(Map.get(event, :Context, %{}), :SequenceNumber, 0)
       end
 
-    result = %ReactorMessage{
-      Content: %OneOf{
-        Value1: %ReactorResult{
+    result = struct(ReactorMessage,
+      Content: struct(OneOf,
+        Value1: struct(ReactorResult,
           Partition: partition,
           State: encode_observation_state(observation_state),
           LastSuccessfulObservation: last_seq,
           ExceptionMessages: exception_messages,
           ExceptionStackTrace: stack_trace
-        }
-      }
-    }
+        )
+      )
+    )
 
     GRPC.Stub.send_request(state.stream, result)
     {:noreply, state}
@@ -175,35 +175,35 @@ defmodule Chronicle.Reactors.Handler do
   defp build_registration(state) do
     event_types =
       Enum.map(state.event_type_map, fn {id, module} ->
-        %EventTypeWithKeyExpression{
-          EventType: %ProtoEventType{
+        struct(EventTypeWithKeyExpression,
+          EventType: struct(ProtoEventType,
             Id: id,
             Generation: module.__chronicle_event_type__(:generation)
-          },
+          ),
           Key: "$eventSourceId"
-        }
+        )
       end)
 
     reactor_id = state.module.__chronicle_reactor__(:id)
     conn_id = if state.session, do: Chronicle.Session.connection_id(state.session), else: generate_connection_id()
 
-    %ReactorMessage{
-      Content: %OneOf{
-        Value0: %RegisterReactor{
+    struct(ReactorMessage,
+      Content: struct(OneOf,
+        Value0: struct(RegisterReactor,
           ConnectionId: conn_id,
           EventStore: state.event_store,
           Namespace: state.namespace,
-          Reactor: %ReactorDefinition{
+          Reactor: struct(ReactorDefinition,
             ReactorId: reactor_id,
             EventSequenceId: "event-log",
             EventTypes: event_types,
             IsReplayable: true,
             Tags: [],
-            Filters: %ObserverFilters{}
-          }
-        }
-      }
-    }
+            Filters: struct(ObserverFilters)
+          )
+        )
+      )
+    )
   end
 
   defp dispatch_event(state, appended_event) do
diff --git a/Source/chronicle/lib/chronicle/read_models.ex b/Source/chronicle/lib/chronicle/read_models.ex
index 2fa52c3..ad17e03 100644
--- a/Source/chronicle/lib/chronicle/read_models.ex
+++ b/Source/chronicle/lib/chronicle/read_models.ex
@@ -51,14 +51,14 @@ defmodule Chronicle.ReadModels do
       model_id = model_module.__chronicle_read_model__(:id)
       event_sequence_id = Keyword.get(opts, :event_sequence_id, @event_log_id)
 
-      request = %GetInstanceByKeyRequest{
+      request = struct(GetInstanceByKeyRequest,
         EventStore: config.event_store,
         Namespace: namespace,
         ReadModelIdentifier: model_id,
         EventSequenceId: event_sequence_id,
         ReadModelKey: key,
         SessionId: ""
-      }
+      )
 
       case ReadModels.Stub.get_instance_by_key(channel, request) do
         {:ok, response} ->
@@ -92,12 +92,12 @@ defmodule Chronicle.ReadModels do
       model_id = model_module.__chronicle_read_model__(:id)
       event_sequence_id = Keyword.get(opts, :event_sequence_id, @event_log_id)
 
-      request = %GetAllInstancesRequest{
+      request = struct(GetAllInstancesRequest,
         EventStore: config.event_store,
         Namespace: namespace,
         ReadModelIdentifier: model_id,
         EventSequenceId: event_sequence_id
-      }
+      )
 
       case ReadModels.Stub.get_all_instances(channel, request) do
         {:ok, response} ->
diff --git a/Source/chronicle/lib/chronicle/reducers/handler.ex b/Source/chronicle/lib/chronicle/reducers/handler.ex
index d54de40..af10871 100644
--- a/Source/chronicle/lib/chronicle/reducers/handler.ex
+++ b/Source/chronicle/lib/chronicle/reducers/handler.ex
@@ -32,7 +32,7 @@ defmodule Chronicle.Reducers.Handler do
   alias Bcl.Guid, as: BclGuid
 
   # MongoDB sink type ID: "22202c41-2be1-4547-9c00-f0b1f797fd75"
-  @mongodb_sink_type_id %BclGuid{lo: 0x45472BE122202C41, hi: 0x75FD97F7B1F0009C}
+  defp mongodb_sink_type_id, do: struct(BclGuid, lo: 0x45472BE122202C41, hi: 0x75FD97F7B1F0009C)
 
   @reconnect_base_delay 1_000
   @reconnect_max_delay 30_000
@@ -117,18 +117,18 @@ defmodule Chronicle.Reducers.Handler do
         model -> model |> Map.from_struct() |> Jason.encode!()
       end
 
-    result = %ReducerMessage{
-      Content: %OneOf{
-        Value1: %ReducerResult{
+    result = struct(ReducerMessage,
+      Content: struct(OneOf,
+        Value1: struct(ReducerResult,
           Partition: partition,
           State: encode_observation_state(observation_state),
           LastSuccessfulObservation: last_seq,
           ExceptionMessages: exception_messages,
           ExceptionStackTrace: stack_trace,
           ReadModelState: read_model_json
-        }
-      }
-    }
+        )
+      )
+    )
 
     GRPC.Stub.send_request(state.stream, result)
     {:noreply, state}
@@ -190,38 +190,38 @@ defmodule Chronicle.Reducers.Handler do
   defp build_registration(state) do
     event_types =
       Enum.map(state.event_type_map, fn {id, module} ->
-        %EventTypeWithKeyExpression{
-          EventType: %ProtoEventType{
+        struct(EventTypeWithKeyExpression,
+          EventType: struct(ProtoEventType,
             Id: id,
             Generation: module.__chronicle_event_type__(:generation)
-          },
+          ),
           Key: "$eventSourceId"
-        }
+        )
       end)
 
     reducer_id = state.module.__chronicle_reducer__(:id)
     model_id = state.model_module.__chronicle_read_model__(:id)
     conn_id = if state.session, do: Chronicle.Session.connection_id(state.session), else: generate_connection_id()
 
-    %ReducerMessage{
-      Content: %OneOf{
-        Value0: %RegisterReducer{
+    struct(ReducerMessage,
+      Content: struct(OneOf,
+        Value0: struct(RegisterReducer,
           ConnectionId: conn_id,
           EventStore: state.event_store,
           Namespace: state.namespace,
-          Reducer: %ReducerDefinition{
+          Reducer: struct(ReducerDefinition,
             ReducerId: reducer_id,
             EventSequenceId: "event-log",
             EventTypes: event_types,
             ReadModel: model_id,
             IsActive: true,
-            Sink: %SinkDefinition{TypeId: @mongodb_sink_type_id},
+            Sink: struct(SinkDefinition, TypeId: mongodb_sink_type_id()),
             Tags: [],
-            Filters: %ObserverFilters{}
-          }
-        }
-      }
-    }
+            Filters: struct(ObserverFilters)
+          )
+        )
+      )
+    )
   end
 
   defp apply_reduce(state, appended_event, model) do
diff --git a/Source/chronicle/lib/chronicle/session.ex b/Source/chronicle/lib/chronicle/session.ex
index 719b3a3..6fd44f0 100644
--- a/Source/chronicle/lib/chronicle/session.ex
+++ b/Source/chronicle/lib/chronicle/session.ex
@@ -127,11 +127,11 @@ defmodule Chronicle.Session do
 
   defp start_session(channel, state) do
     try do
-      request = %ConnectRequest{
+      request = struct(ConnectRequest,
         ConnectionId: state.connection_id,
         ClientVersion: "1.0.0",
         IsRunningWithDebugger: false
-      }
+      )
 
       case ConnectionService.Stub.connect(channel, request) do
         {:ok, reply_stream} ->