diff --git a/groups/ntc/ntccfg/ntccfg_traits.h b/groups/ntc/ntccfg/ntccfg_traits.h
index 363366c51..dc69c3d2a 100644
--- a/groups/ntc/ntccfg/ntccfg_traits.h
+++ b/groups/ntc/ntccfg/ntccfg_traits.h
@@ -26,12 +26,10 @@ BSLS_IDENT("$Id: $")
 /// Declare the specified 'TYPE' is bitwise-movable.
 /// @ingroup module_ntccfg
 #define NTCCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(TYPE)                    \
-    BSLALG_DECLARE_NESTED_TRAITS4(                                            \
+    BSLALG_DECLARE_NESTED_TRAITS2(                                            \
         TYPE,                                                                 \
         bslalg::TypeTraitBitwiseMoveable,                                     \
-        bslalg::TypeTraitBitwiseCopyable,                                     \
-        bslalg::TypeTraitBitwiseEqualityComparable,                           \
-        bslalg::TypeTraitHasTrivialDefaultConstructor)
+        bslalg::TypeTraitBitwiseCopyable)
 
 /// Declare the specified 'TYPE' uses an allocator to supply memory.
 /// @ingroup module_ntccfg
diff --git a/groups/nts/ntsa/ntsa_abstract.h b/groups/nts/ntsa/ntsa_abstract.h
index faa327996..405afdce4 100644
--- a/groups/nts/ntsa/ntsa_abstract.h
+++ b/groups/nts/ntsa/ntsa_abstract.h
@@ -359,10 +359,9 @@ class AbstractSyntaxEncoderOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractSyntaxEncoderOptions);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractSyntaxEncoderOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
@@ -879,10 +878,9 @@ class AbstractSyntaxDecoderOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractSyntaxDecoderOptions);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractSyntaxDecoderOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
@@ -1045,10 +1043,15 @@ class AbstractSyntaxDecoderFrame
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(AbstractSyntaxDecoderFrame);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(AbstractSyntaxDecoderFrame);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(AbstractSyntaxDecoderFrame);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
@@ -1615,10 +1618,9 @@ class AbstractObjectIdentifier
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractObjectIdentifier);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractObjectIdentifier);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -1774,10 +1776,9 @@ class AbstractValue
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractValue);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractValue);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -1930,10 +1931,9 @@ class AbstractString
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractString);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractString);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -2090,10 +2090,9 @@ class AbstractByteSequence
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractByteSequence);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractByteSequence);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -2270,10 +2269,9 @@ class AbstractBitSequence
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractBitSequence);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractBitSequence);
 };
 
 /// Define a type alias for the representation of an abstract octet sequence.
@@ -2652,10 +2650,9 @@ class AbstractIntegerRepresentation
                          AbstractIntegerSign::Value           sign,
                          AbstractIntegerBase::Value           base);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractIntegerRepresentation);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractIntegerRepresentation);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -3302,10 +3299,9 @@ class AbstractIntegerQuantity
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractIntegerQuantity);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractIntegerQuantity);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
@@ -4037,10 +4033,9 @@ class AbstractInteger
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(AbstractInteger);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(AbstractInteger);
 };
 
 /// Format the specified 'object' to the specified output 'stream' and
diff --git a/groups/nts/ntsa/ntsa_adapter.h b/groups/nts/ntsa/ntsa_adapter.h
index 4851bf5ac..d679efa5e 100644
--- a/groups/nts/ntsa/ntsa_adapter.h
+++ b/groups/nts/ntsa/ntsa_adapter.h
@@ -113,6 +113,10 @@ class Adapter
     /// Return the flag that indicates this adapter can be a multicast
     /// recipient.
     bool multicast() const;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Adapter);
 };
 
 }  // close package namespace
diff --git a/groups/nts/ntsa/ntsa_buffer.h b/groups/nts/ntsa/ntsa_buffer.h
index b811d55d3..29b35a925 100644
--- a/groups/nts/ntsa/ntsa_buffer.h
+++ b/groups/nts/ntsa/ntsa_buffer.h
@@ -149,11 +149,19 @@ class MutableBuffer
                      bsl::size_t                bufferCount,
                      bsl::size_t                offset);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(MutableBuffer,
-                                 bslalg::TypeTraitBitwiseCopyable);
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(MutableBuffer);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(MutableBuffer);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(MutableBuffer);
 };
 
 /// Return true if the specified 'lhs' has the same value as the specified
@@ -292,11 +300,19 @@ class ConstBuffer
                      bsl::size_t              bufferCount,
                      bsl::size_t              offset);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(ConstBuffer,
-                                 bslalg::TypeTraitBitwiseCopyable);
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(ConstBuffer);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ConstBuffer);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ConstBuffer);
 };
 
 /// Return true if the specified 'lhs' has the same value as the specified
@@ -424,11 +440,9 @@ class ConstBufferArray
                        const bdlbb::Blob&      data,
                        bsl::size_t             maxBytes);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(ConstBufferArray,
-                                 bslalg::TypeTraitUsesBslmaAllocator);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(ConstBufferArray);
 };
 
 /// Provide a held pointer to an array of contiguous pointers to potentially
@@ -506,11 +520,19 @@ class ConstBufferPtrArray
     /// array.
     bsl::size_t numBytes() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(ConstBufferPtrArray,
-                                 bslalg::TypeTraitBitwiseCopyable);
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(ConstBufferPtrArray);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ConstBufferPtrArray);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ConstBufferPtrArray);
 };
 
 /// Provide an array of contiguous pointers to potentially discontiguous,
@@ -626,11 +648,9 @@ class MutableBufferArray
                         bdlbb::Blob*              data,
                         bsl::size_t               maxBytes);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(MutableBufferArray,
-                                 bslalg::TypeTraitUsesBslmaAllocator);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(MutableBufferArray);
 };
 
 /// Provide a held pointer to an array of contiguous pointers to potentially
@@ -709,11 +729,19 @@ class MutableBufferPtrArray
     /// array.
     bsl::size_t numBytes() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(MutableBufferPtrArray,
-                                 bslalg::TypeTraitBitwiseCopyable);
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(MutableBufferPtrArray);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(MutableBufferPtrArray);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(MutableBufferPtrArray);
 };
 
 /// Provide a sequence of non-modifiable buffers.
@@ -1219,6 +1247,10 @@ class StreamBuffer : public bsl::streambuf
 
     /// Return the number of writable bytes.
     bsl::size_t capacity() const;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(StreamBuffer);
 };
 
 NTSCFG_INLINE
diff --git a/groups/nts/ntsa/ntsa_data.h b/groups/nts/ntsa/ntsa_data.h
index e40b3e873..0c29199a2 100644
--- a/groups/nts/ntsa/ntsa_data.h
+++ b/groups/nts/ntsa/ntsa_data.h
@@ -539,10 +539,9 @@ class Data
     /// Return the allocator used by this data container.
     bslma::Allocator* allocator() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(Data);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Data);
 };
 
 /// Provide utilities for data containers.
diff --git a/groups/nts/ntsa/ntsa_distinguishedname.h b/groups/nts/ntsa/ntsa_distinguishedname.h
index 8bf99c30f..2f31daca9 100644
--- a/groups/nts/ntsa/ntsa_distinguishedname.h
+++ b/groups/nts/ntsa/ntsa_distinguishedname.h
@@ -262,13 +262,9 @@ class DistinguishedName
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(DistinguishedName,
-                                 bslalg::TypeTraitUsesBslmaAllocator);
-
-    // FRIEND OPERATORS
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(DistinguishedName);
 
     /// Format the specified 'rhs' to the specified output 'stream' and
     /// return a reference to the modifiable 'stream'.
@@ -347,13 +343,9 @@ class DistinguishedName::Component
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    BSLALG_DECLARE_NESTED_TRAITS(Component,
-                                 bslalg::TypeTraitUsesBslmaAllocator);
-
-    // FRIEND OPERATORS
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Component);
 
     /// Format the specified 'rhs' to the specified output 'stream' and
     /// return a reference to the modifiable 'stream'.
diff --git a/groups/nts/ntsa/ntsa_domainname.h b/groups/nts/ntsa/ntsa_domainname.h
index f12035e79..edc3e2041 100644
--- a/groups/nts/ntsa/ntsa_domainname.h
+++ b/groups/nts/ntsa/ntsa_domainname.h
@@ -235,10 +235,15 @@ class DomainName
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(DomainName);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(DomainName);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(DomainName);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a
diff --git a/groups/nts/ntsa/ntsa_endpoint.h b/groups/nts/ntsa/ntsa_endpoint.h
index a5191deec..c3f73b9c2 100644
--- a/groups/nts/ntsa/ntsa_endpoint.h
+++ b/groups/nts/ntsa/ntsa_endpoint.h
@@ -306,10 +306,15 @@ class Endpoint
     static const bdlat_SelectionInfo* lookupSelectionInfo(const char* name,
                                                           int nameLength);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Endpoint);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Endpoint);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Endpoint);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a
diff --git a/groups/nts/ntsa/ntsa_endpointoptions.h b/groups/nts/ntsa/ntsa_endpointoptions.h
index 32cc13a05..f5ab7756b 100644
--- a/groups/nts/ntsa/ntsa_endpointoptions.h
+++ b/groups/nts/ntsa/ntsa_endpointoptions.h
@@ -213,10 +213,15 @@ class EndpointOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(EndpointOptions);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(EndpointOptions);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(EndpointOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_error.h b/groups/nts/ntsa/ntsa_error.h
index 7c0104d4f..fe06bffe4 100644
--- a/groups/nts/ntsa/ntsa_error.h
+++ b/groups/nts/ntsa/ntsa_error.h
@@ -251,10 +251,19 @@ class Error
     /// Return the last error.
     static ntsa::Error last();
 
-    // Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Error);
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(Error);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Error);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Error);
 };
 
 /// Return true if the specified 'lhs' has the same value as the specified
diff --git a/groups/nts/ntsa/ntsa_event.h b/groups/nts/ntsa/ntsa_event.h
index 3985e35fe..ee40dbefe 100644
--- a/groups/nts/ntsa/ntsa_event.h
+++ b/groups/nts/ntsa/ntsa_event.h
@@ -224,10 +224,15 @@ class Event
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Event);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Event);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Event);
 };
 
 /// Insert a formatted, human-readable description of the specified 'value'
@@ -426,10 +431,9 @@ class EventSet
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(EventSet);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(EventSet);
 };
 
 /// Insert a formatted, human-readable description of the specified 'value'
diff --git a/groups/nts/ntsa/ntsa_file.h b/groups/nts/ntsa/ntsa_file.h
index 56321140f..e5f403f4f 100644
--- a/groups/nts/ntsa/ntsa_file.h
+++ b/groups/nts/ntsa/ntsa_file.h
@@ -101,10 +101,15 @@ class File
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(File);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(File);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(File);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a
diff --git a/groups/nts/ntsa/ntsa_guid.h b/groups/nts/ntsa/ntsa_guid.h
index 0d969341e..f632bfd97 100644
--- a/groups/nts/ntsa/ntsa_guid.h
+++ b/groups/nts/ntsa/ntsa_guid.h
@@ -287,9 +287,27 @@ class Guid
 
     /// Return the timestamp component of this GUID object value.
     bsl::uint64_t timestamp() const;
-};
 
-// FREE OPERATORS
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(Guid);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Guid);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Guid);
+
+    /// This type's equality-comparison operator is equivalent to comparing
+    /// each byte of one comparand's footprint to each corresponding byte of
+    /// the other comparand's footprint. Note that this trait implies that an
+    /// object of this type has no padding bytes between data members.
+    NTSCFG_TYPE_TRAIT_BITWISE_COMPARABLE(Guid);
+};
 
 /// Return true if the specified 'lhs' has the same value as the specified
 /// 'rhs', otherwise return false.
diff --git a/groups/nts/ntsa/ntsa_host.h b/groups/nts/ntsa/ntsa_host.h
index 3ed627512..f02170dd5 100644
--- a/groups/nts/ntsa/ntsa_host.h
+++ b/groups/nts/ntsa/ntsa_host.h
@@ -286,10 +286,15 @@ class Host
     static const bdlat_SelectionInfo* lookupSelectionInfo(const char* name,
                                                           int nameLength);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Host);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Host);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Host);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_id.h b/groups/nts/ntsa/ntsa_id.h
index 3d1d96bba..7993b979f 100644
--- a/groups/nts/ntsa/ntsa_id.h
+++ b/groups/nts/ntsa/ntsa_id.h
@@ -120,9 +120,21 @@ class Id
 
     /// Return a new identifier locally unique to the current process.
     static Id generate();
-};
 
-// FREE OPERATORS
+    /// This type's default constructor is equivalent to setting each byte of
+    /// the object's footprint to zero.
+    NTSCFG_TYPE_TRAIT_BITWISE_INITIALIZABLE(Id);
+
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Id);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Id);
+};
 
 /// Write the specified 'value' to the specified 'stream' in a
 /// human-readable format. Return a reference to the modifiable 'stream'.
diff --git a/groups/nts/ntsa/ntsa_interest.h b/groups/nts/ntsa/ntsa_interest.h
index f33368974..e99b01f51 100644
--- a/groups/nts/ntsa/ntsa_interest.h
+++ b/groups/nts/ntsa/ntsa_interest.h
@@ -83,8 +83,6 @@ struct InterestType {
     static bsl::ostream& print(bsl::ostream& stream, Value value);
 };
 
-// FREE OPERATORS
-
 /// Format the specified 'rhs' to the specified output 'stream' and return a
 /// reference to the modifiable 'stream'.
 ///
@@ -185,10 +183,15 @@ class Interest
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to
-    /// select, at compile-time, the most efficient algorithm to manipulate
-    /// objects of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Interest);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Interest);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Interest);
 };
 
 /// Insert a formatted, human-readable description of the specified 'value'
@@ -409,10 +412,9 @@ class InterestSet
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(InterestSet);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(InterestSet);
 };
 
 /// Insert a formatted, human-readable description of the specified 'value'
diff --git a/groups/nts/ntsa/ntsa_ipaddress.h b/groups/nts/ntsa/ntsa_ipaddress.h
index 7b1dd9b9a..535af8b1d 100644
--- a/groups/nts/ntsa/ntsa_ipaddress.h
+++ b/groups/nts/ntsa/ntsa_ipaddress.h
@@ -231,10 +231,15 @@ class IpAddress
     /// the loopback address.
     static ntsa::IpAddress loopback(ntsa::IpAddressType::Value addressType);
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(IpAddress);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(IpAddress);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(IpAddress);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_ipaddressoptions.h b/groups/nts/ntsa/ntsa_ipaddressoptions.h
index 3b014550f..299a96174 100644
--- a/groups/nts/ntsa/ntsa_ipaddressoptions.h
+++ b/groups/nts/ntsa/ntsa_ipaddressoptions.h
@@ -167,10 +167,15 @@ class IpAddressOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(IpAddressOptions);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(IpAddressOptions);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(IpAddressOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_ipendpoint.h b/groups/nts/ntsa/ntsa_ipendpoint.h
index a8476bbb0..3b191c1b4 100644
--- a/groups/nts/ntsa/ntsa_ipendpoint.h
+++ b/groups/nts/ntsa/ntsa_ipendpoint.h
@@ -281,10 +281,15 @@ class IpEndpoint
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[2];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(IpEndpoint);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(IpEndpoint);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(IpEndpoint);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_ipv4endpoint.h b/groups/nts/ntsa/ntsa_ipv4endpoint.h
index 9edbc88b2..392a4bfe9 100644
--- a/groups/nts/ntsa/ntsa_ipv4endpoint.h
+++ b/groups/nts/ntsa/ntsa_ipv4endpoint.h
@@ -163,10 +163,15 @@ class Ipv4Endpoint
     /// Return the port number that represents any port.
     static ntsa::Port anyPort();
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Ipv4Endpoint);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Ipv4Endpoint);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Ipv4Endpoint);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_ipv6endpoint.h b/groups/nts/ntsa/ntsa_ipv6endpoint.h
index c7b8eec48..13611b0e0 100644
--- a/groups/nts/ntsa/ntsa_ipv6endpoint.h
+++ b/groups/nts/ntsa/ntsa_ipv6endpoint.h
@@ -165,10 +165,15 @@ class Ipv6Endpoint
     /// Return the port number that represents any port.
     static ntsa::Port anyPort();
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Ipv6Endpoint);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Ipv6Endpoint);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Ipv6Endpoint);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_ipv6scopeid.h b/groups/nts/ntsa/ntsa_ipv6scopeid.h
index d5e69df9a..f0af5312d 100644
--- a/groups/nts/ntsa/ntsa_ipv6scopeid.h
+++ b/groups/nts/ntsa/ntsa_ipv6scopeid.h
@@ -37,7 +37,11 @@ typedef bsl::uint32_t Ipv6ScopeId;
 ///
 /// @ingroup module_ntsa_identity
 struct Ipv6ScopeIdUtil {
-    enum { MAX_LENGTH = 5 };
+    enum { 
+        /// The maximum length of the string representation of an IPv6 scope 
+        /// ID, not including the null terminator.
+        MAX_LENGTH = 5 
+    };
 
     /// Encode the specified 'scopeId' to the specified 'destination' having
     /// the specified 'capacity'. Return the number of bytes written.
diff --git a/groups/nts/ntsa/ntsa_linger.h b/groups/nts/ntsa/ntsa_linger.h
index 56d41ef75..e5b210054 100644
--- a/groups/nts/ntsa/ntsa_linger.h
+++ b/groups/nts/ntsa/ntsa_linger.h
@@ -112,10 +112,15 @@ class Linger
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Linger);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Linger);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Linger);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_localname.h b/groups/nts/ntsa/ntsa_localname.h
index 26410e7aa..82a4a362a 100644
--- a/groups/nts/ntsa/ntsa_localname.h
+++ b/groups/nts/ntsa/ntsa_localname.h
@@ -238,10 +238,15 @@ class LocalName
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[2];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(LocalName);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(LocalName);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(LocalName);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_message.h b/groups/nts/ntsa/ntsa_message.h
index b5bf114f8..68b5d109c 100644
--- a/groups/nts/ntsa/ntsa_message.h
+++ b/groups/nts/ntsa/ntsa_message.h
@@ -85,10 +85,9 @@ class Message
     /// Return the length of the message.
     bsl::size_t length() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(Message);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Message);
 };
 
 /// Provide a  contiguous sequence of buffers of non-modifable, potentially
@@ -168,10 +167,9 @@ class ConstMessage
     /// Return the capacity of the message.
     bsl::size_t capacity() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(ConstMessage);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(ConstMessage);
 };
 
 /// Provide a contiguous sequence of buffers of modifable, potentially
@@ -250,10 +248,9 @@ class MutableMessage
     /// Return the capacity of the message.
     bsl::size_t capacity() const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(MutableMessage);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(MutableMessage);
 };
 
 NTSCFG_INLINE
diff --git a/groups/nts/ntsa/ntsa_notification.h b/groups/nts/ntsa/ntsa_notification.h
index e2f114e81..38e795568 100644
--- a/groups/nts/ntsa/ntsa_notification.h
+++ b/groups/nts/ntsa/ntsa_notification.h
@@ -127,10 +127,15 @@ class Notification
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select, at
-    /// compile-time, the most efficient algorithm to manipulate objects of
-    /// this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Notification);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Notification);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Notification);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a modifiable
diff --git a/groups/nts/ntsa/ntsa_notificationqueue.h b/groups/nts/ntsa/ntsa_notificationqueue.h
index 7761f226f..936a60868 100644
--- a/groups/nts/ntsa/ntsa_notificationqueue.h
+++ b/groups/nts/ntsa/ntsa_notificationqueue.h
@@ -93,10 +93,9 @@ class NotificationQueue
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(NotificationQueue);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(NotificationQueue);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a
diff --git a/groups/nts/ntsa/ntsa_port.h b/groups/nts/ntsa/ntsa_port.h
index 9f9631465..7e6951dab 100644
--- a/groups/nts/ntsa/ntsa_port.h
+++ b/groups/nts/ntsa/ntsa_port.h
@@ -38,7 +38,8 @@ typedef bsl::uint16_t Port;
 /// @ingroup module_ntsa_identity
 struct PortUtil {
     enum {
-        /// The maximum number of digits in a port number.
+        /// The maximum length of the string representation of a port number,
+        /// not including the null terminator.
         MAX_LENGTH = 5
     };
 
diff --git a/groups/nts/ntsa/ntsa_portoptions.h b/groups/nts/ntsa/ntsa_portoptions.h
index eef69697d..8ee0808bd 100644
--- a/groups/nts/ntsa/ntsa_portoptions.h
+++ b/groups/nts/ntsa/ntsa_portoptions.h
@@ -145,10 +145,15 @@ class PortOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(PortOptions);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(PortOptions);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(PortOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_reactorconfig.h b/groups/nts/ntsa/ntsa_reactorconfig.h
index 72f35dd2f..ecb19961d 100644
--- a/groups/nts/ntsa/ntsa_reactorconfig.h
+++ b/groups/nts/ntsa/ntsa_reactorconfig.h
@@ -161,10 +161,9 @@ class ReactorConfig
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(ReactorConfig);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(ReactorConfig);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_receivecontext.h b/groups/nts/ntsa/ntsa_receivecontext.h
index 8426368e7..31c6374cc 100644
--- a/groups/nts/ntsa/ntsa_receivecontext.h
+++ b/groups/nts/ntsa/ntsa_receivecontext.h
@@ -200,10 +200,15 @@ class ReceiveContext
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(ReceiveContext);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ReceiveContext);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ReceiveContext);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_receiveoptions.h b/groups/nts/ntsa/ntsa_receiveoptions.h
index c06daca3c..acb22a12d 100644
--- a/groups/nts/ntsa/ntsa_receiveoptions.h
+++ b/groups/nts/ntsa/ntsa_receiveoptions.h
@@ -209,10 +209,15 @@ class ReceiveOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(ReceiveOptions);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ReceiveOptions);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ReceiveOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_resolverconfig.h b/groups/nts/ntsa/ntsa_resolverconfig.h
index 7ace607cd..79a80912c 100644
--- a/groups/nts/ntsa/ntsa_resolverconfig.h
+++ b/groups/nts/ntsa/ntsa_resolverconfig.h
@@ -111,10 +111,15 @@ class ResolverConfig
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(ResolverConfig);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ResolverConfig);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ResolverConfig);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_sendcontext.h b/groups/nts/ntsa/ntsa_sendcontext.h
index d7e88ebc1..7f9f0d9c7 100644
--- a/groups/nts/ntsa/ntsa_sendcontext.h
+++ b/groups/nts/ntsa/ntsa_sendcontext.h
@@ -167,10 +167,15 @@ class SendContext
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(SendContext);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(SendContext);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(SendContext);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_sendoptions.h b/groups/nts/ntsa/ntsa_sendoptions.h
index fbe4babe3..d56362963 100644
--- a/groups/nts/ntsa/ntsa_sendoptions.h
+++ b/groups/nts/ntsa/ntsa_sendoptions.h
@@ -175,10 +175,15 @@ class SendOptions
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(SendOptions);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(SendOptions);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(SendOptions);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_socketconfig.h b/groups/nts/ntsa/ntsa_socketconfig.h
index a03bf9e4d..723f07597 100644
--- a/groups/nts/ntsa/ntsa_socketconfig.h
+++ b/groups/nts/ntsa/ntsa_socketconfig.h
@@ -320,10 +320,15 @@ class SocketConfig
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(SocketConfig);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(SocketConfig);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(SocketConfig);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_socketinfo.h b/groups/nts/ntsa/ntsa_socketinfo.h
index dfa1e2dfa..4e2eb15f3 100644
--- a/groups/nts/ntsa/ntsa_socketinfo.h
+++ b/groups/nts/ntsa/ntsa_socketinfo.h
@@ -164,10 +164,15 @@ class SocketInfo
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(SocketInfo);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(SocketInfo);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(SocketInfo);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_socketinfofilter.h b/groups/nts/ntsa/ntsa_socketinfofilter.h
index e73d6ff01..2ae3bcc99 100644
--- a/groups/nts/ntsa/ntsa_socketinfofilter.h
+++ b/groups/nts/ntsa/ntsa_socketinfofilter.h
@@ -113,10 +113,15 @@ class SocketInfoFilter
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(SocketInfoFilter);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(SocketInfoFilter);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(SocketInfoFilter);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_socketoption.h b/groups/nts/ntsa/ntsa_socketoption.h
index 13a9e4ed6..ed0916638 100644
--- a/groups/nts/ntsa/ntsa_socketoption.h
+++ b/groups/nts/ntsa/ntsa_socketoption.h
@@ -576,10 +576,9 @@ class SocketOption
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select, at
-    /// compile-time, the most efficient algorithm to manipulate objects of
-    /// this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(SocketOption);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(SocketOption);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a modifiable
diff --git a/groups/nts/ntsa/ntsa_temporary.h b/groups/nts/ntsa/ntsa_temporary.h
index f1580a8b0..33ce32a7b 100644
--- a/groups/nts/ntsa/ntsa_temporary.h
+++ b/groups/nts/ntsa/ntsa_temporary.h
@@ -88,6 +88,10 @@ class TemporaryDirectory
 
     /// Return the path to the directory.
     const bsl::string& path() const;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(TemporaryDirectory);
 };
 
 /// Provide a temporary file.
@@ -161,6 +165,10 @@ class TemporaryFile
 
     // Return the path to the file.
     const bsl::string& path() const;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(TemporaryFile);
 };
 
 }  // close package namespace
diff --git a/groups/nts/ntsa/ntsa_timestamp.h b/groups/nts/ntsa/ntsa_timestamp.h
index 8393423e8..64c56f087 100644
--- a/groups/nts/ntsa/ntsa_timestamp.h
+++ b/groups/nts/ntsa/ntsa_timestamp.h
@@ -107,10 +107,15 @@ class Timestamp
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(Timestamp);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(Timestamp);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(Timestamp);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsa/ntsa_uri.h b/groups/nts/ntsa/ntsa_uri.h
index f06364677..4040e5092 100644
--- a/groups/nts/ntsa/ntsa_uri.h
+++ b/groups/nts/ntsa/ntsa_uri.h
@@ -231,10 +231,9 @@ class UriAuthority
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[4];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(UriAuthority);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(UriAuthority);
 };
 
 /// Insert a formatted, human-readable description of the the specified
@@ -420,10 +419,9 @@ class UriParameter
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[2];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(UriParameter);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(UriParameter);
 };
 
 /// Insert a formatted, human-readable description of the the specified
@@ -609,10 +607,9 @@ class UriQuery
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[1];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(UriQuery);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(UriQuery);
 };
 
 /// Insert a formatted, human-readable description of the the specified
@@ -888,10 +885,9 @@ class Uri
     /// The attribute info array, indexed by attribute index.
     static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[5];
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(Uri);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Uri);
 };
 
 /// Insert a formatted, human-readable description of the the specified
diff --git a/groups/nts/ntsa/ntsa_zerocopy.h b/groups/nts/ntsa/ntsa_zerocopy.h
index 272877604..ed84e2d76 100644
--- a/groups/nts/ntsa/ntsa_zerocopy.h
+++ b/groups/nts/ntsa/ntsa_zerocopy.h
@@ -166,10 +166,15 @@ class ZeroCopy
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(ZeroCopy);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(ZeroCopy);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(ZeroCopy);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return a modifiable
diff --git a/groups/nts/ntsb/ntsb_resolver.h b/groups/nts/ntsb/ntsb_resolver.h
index 4a26e887d..fa5405945 100644
--- a/groups/nts/ntsb/ntsb_resolver.h
+++ b/groups/nts/ntsb/ntsb_resolver.h
@@ -190,6 +190,10 @@ class ResolverOverrides
 
     /// Return the canonical, fully-qualified hostname of the local machine.
     ntsa::Error getHostnameFullyQualified(bsl::string* result) const;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(ResolverOverrides);
 };
 
 /// Provide a blocking resolver implemented by the system.
@@ -390,6 +394,10 @@ class Resolver : public ntsi::Resolver
     /// Return the canonical, fully-qualified hostname of the local machine.
     ntsa::Error getHostnameFullyQualified(bsl::string* result)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Resolver);
 };
 
 }  // close package namespace
diff --git a/groups/nts/ntsd/ntsd_message.h b/groups/nts/ntsd/ntsd_message.h
index 82af8bfe4..c6e25ba51 100644
--- a/groups/nts/ntsd/ntsd_message.h
+++ b/groups/nts/ntsd/ntsd_message.h
@@ -262,10 +262,9 @@ class Message
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_USES_ALLOCATOR_TRAITS(Message);
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Message);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsd/ntsd_messageheader.h b/groups/nts/ntsd/ntsd_messageheader.h
index 3857e4b85..2e69d4d52 100644
--- a/groups/nts/ntsd/ntsd_messageheader.h
+++ b/groups/nts/ntsd/ntsd_messageheader.h
@@ -248,10 +248,15 @@ class MessageHeader
                         int           level          = 0,
                         int           spacesPerLevel = 4) const;
 
-    /// Defines the traits of this type. These traits can be used to select,
-    /// at compile-time, the most efficient algorithm to manipulate objects
-    /// of this type.
-    NTSCFG_DECLARE_NESTED_BITWISE_MOVABLE_TRAITS(MessageHeader);
+    /// This type's copy-constructor and copy-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_COPYABLE(MessageHeader);
+
+    /// This type's move-constructor and move-assignment operator is equivalent
+    /// to copying each byte of the source object's footprint to each
+    /// corresponding byte of the destination object's footprint.
+    NTSCFG_TYPE_TRAIT_BITWISE_MOVABLE(MessageHeader);
 };
 
 /// Write the specified 'object' to the specified 'stream'. Return
diff --git a/groups/nts/ntsd/ntsd_messageparser.h b/groups/nts/ntsd/ntsd_messageparser.h
index 66cc7fef3..a35f6dd25 100644
--- a/groups/nts/ntsd/ntsd_messageparser.h
+++ b/groups/nts/ntsd/ntsd_messageparser.h
@@ -82,6 +82,10 @@ class MessageParser
     ntsa::Error parse(ntsd::Message* message,
                       int*           numNeeded,
                       bdlbb::Blob*   readQueue);
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(MessageParser);
 };
 
 }  // close package namespace
diff --git a/groups/nts/ntso/ntso_devpoll.cpp b/groups/nts/ntso/ntso_devpoll.cpp
index 08bc22d1c..df107462c 100644
--- a/groups/nts/ntso/ntso_devpoll.cpp
+++ b/groups/nts/ntso/ntso_devpoll.cpp
@@ -192,6 +192,10 @@ class Devpoll : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Devpoll);
 };
 
 ntsa::Error Devpoll::update(ntsa::Handle          socket,
diff --git a/groups/nts/ntso/ntso_epoll.cpp b/groups/nts/ntso/ntso_epoll.cpp
index 62ef0c0c3..0226c27fa 100644
--- a/groups/nts/ntso/ntso_epoll.cpp
+++ b/groups/nts/ntso/ntso_epoll.cpp
@@ -188,6 +188,10 @@ class Epoll : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Epoll);
 };
 
 bsl::uint32_t Epoll::specify(const ntsa::Interest& interest)
diff --git a/groups/nts/ntso/ntso_eventport.cpp b/groups/nts/ntso/ntso_eventport.cpp
index facd67b5f..cbbe2f4c1 100644
--- a/groups/nts/ntso/ntso_eventport.cpp
+++ b/groups/nts/ntso/ntso_eventport.cpp
@@ -195,6 +195,10 @@ class EventPort : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(EventPort);
 };
 
 ntsa::Error EventPort::update(ntsa::Handle          socket,
diff --git a/groups/nts/ntso/ntso_kqueue.cpp b/groups/nts/ntso/ntso_kqueue.cpp
index 77800683e..570cd42cb 100644
--- a/groups/nts/ntso/ntso_kqueue.cpp
+++ b/groups/nts/ntso/ntso_kqueue.cpp
@@ -214,6 +214,10 @@ class Kqueue : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Kqueue);
 };
 
 Kqueue::Kqueue(const ntsa::ReactorConfig& configuration,
diff --git a/groups/nts/ntso/ntso_poll.cpp b/groups/nts/ntso/ntso_poll.cpp
index 649834809..d8d515d56 100644
--- a/groups/nts/ntso/ntso_poll.cpp
+++ b/groups/nts/ntso/ntso_poll.cpp
@@ -197,6 +197,10 @@ class Poll : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Poll);
 };
 
 short Poll::specify(const ntsa::Interest& interest)
diff --git a/groups/nts/ntso/ntso_pollset.cpp b/groups/nts/ntso/ntso_pollset.cpp
index 7371d7792..3277c2754 100644
--- a/groups/nts/ntso/ntso_pollset.cpp
+++ b/groups/nts/ntso/ntso_pollset.cpp
@@ -193,6 +193,10 @@ class Pollset : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Pollset);
 };
 
 ntsa::Error Pollset::update(ntsa::Handle          socket,
diff --git a/groups/nts/ntso/ntso_select.cpp b/groups/nts/ntso/ntso_select.cpp
index b6f15b76f..994022a2b 100644
--- a/groups/nts/ntso/ntso_select.cpp
+++ b/groups/nts/ntso/ntso_select.cpp
@@ -210,6 +210,10 @@ class Select : public ntsi::Reactor
     ntsa::Error wait(ntsa::EventSet*                                result,
                      const bdlb::NullableValue<bsls::TimeInterval>& deadline)
         BSLS_KEYWORD_OVERRIDE;
+
+    /// This type accepts an allocator argument to its constructors and may
+    /// dynamically allocate memory during its operation.
+    NTSCFG_TYPE_TRAIT_ALLOCATOR_AWARE(Select);
 };
 
 void Select::copy(fd_set* destination, const fd_set& source)