qnty 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

qnty/quantities/field_vars.pyi

@@ -0,0 +1,4191 @@
+"""
+Type stubs for quantities module - Complete Edition.
+
+Provides complete type hints for IDE autocomplete and type checking
+for quantity classes and their setter relationships.
+Contains 107 quantity types with 871 total units.
+
+Auto-generated from unit_data.json.
+"""
+
+from ..dimensions import field_dims as dim
+from . import field_setter as ts
+from .field_qnty import FieldQnty
+
+# ===== CONVERTER TYPE STUBS =====
+# Unit conversion handled by base ToUnitConverter and AsUnitConverter classes
+# with dynamic __getattr__ for unit method type hints
+
+# ===== QUANTITY CLASSES =====
+# Type stubs for quantity classes with setter relationships
+
+class AbsorbedDose(FieldQnty):
+    """
+    Type-safe absorbed radiation dose quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AbsorbedDose("variable_name") -> Create unknown absorbed radiation dose
+    - AbsorbedDose(value, "unit", "variable_name") -> Create known absorbed radiation dose
+
+    Examples:
+    ---------
+    >>> unknown = AbsorbedDose("pressure")  # Unknown absorbed radiation dose
+    >>> known = AbsorbedDose(100, "erg_per_gram", "inlet_pressure")  # Known absorbed radiation dose
+
+    Available units: "erg_per_gram", "gram_rad", "gray"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AbsorbedDoseSetter
+    _dimension = dim.ABSORBED_DOSE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AbsorbedDoseSetter:
+        """
+        Create a setter for this absorbed radiation dose quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AbsorbedDoseSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Acceleration(FieldQnty):
+    """
+    Type-safe acceleration quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Acceleration("variable_name") -> Create unknown acceleration
+    - Acceleration(value, "unit", "variable_name") -> Create known acceleration
+
+    Examples:
+    ---------
+    >>> unknown = Acceleration("pressure")  # Unknown acceleration
+    >>> known = Acceleration(100, "meter_per_second_squared", "inlet_pressure")  # Known acceleration
+
+    Available units: "meter_per_second_squared", "foot_per_second_squared"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AccelerationSetter
+    _dimension = dim.ACCELERATION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AccelerationSetter:
+        """
+        Create a setter for this acceleration quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AccelerationSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ActivationEnergy(FieldQnty):
+    """
+    Type-safe activation energy quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ActivationEnergy("variable_name") -> Create unknown activation energy
+    - ActivationEnergy(value, "unit", "variable_name") -> Create known activation energy
+
+    Examples:
+    ---------
+    >>> unknown = ActivationEnergy("pressure")  # Unknown activation energy
+    >>> known = ActivationEnergy(100, "btu_per_pound_mole", "inlet_pressure")  # Known activation energy
+
+    Available units: "btu_per_pound_mole", "calorie_mean_per_gram_mole", "joule_per_gram_mole"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ActivationEnergySetter
+    _dimension = dim.ACTIVATION_ENERGY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ActivationEnergySetter:
+        """
+        Create a setter for this activation energy quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ActivationEnergySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AmountOfSubstance(FieldQnty):
+    """
+    Type-safe amount of substance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AmountOfSubstance("variable_name") -> Create unknown amount of substance
+    - AmountOfSubstance(value, "unit", "variable_name") -> Create known amount of substance
+
+    Examples:
+    ---------
+    >>> unknown = AmountOfSubstance("pressure")  # Unknown amount of substance
+    >>> known = AmountOfSubstance(100, "kilogram_mol", "inlet_pressure")  # Known amount of substance
+
+    Available units: "kilogram_mol", "mole", "pound_mole"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AmountOfSubstanceSetter
+    _dimension = dim.AMOUNT_OF_SUBSTANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AmountOfSubstanceSetter:
+        """
+        Create a setter for this amount of substance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AmountOfSubstanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AnglePlane(FieldQnty):
+    """
+    Type-safe angle, plane quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AnglePlane("variable_name") -> Create unknown angle, plane
+    - AnglePlane(value, "unit", "variable_name") -> Create known angle, plane
+
+    Examples:
+    ---------
+    >>> unknown = AnglePlane("pressure")  # Unknown angle, plane
+    >>> known = AnglePlane(100, "degree", "inlet_pressure")  # Known angle, plane
+
+    Available units: "degree", "gon", "grade"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AnglePlaneSetter
+    _dimension = dim.ANGLE_PLANE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AnglePlaneSetter:
+        """
+        Create a setter for this angle, plane quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AnglePlaneSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AngleSolid(FieldQnty):
+    """
+    Type-safe angle, solid quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AngleSolid("variable_name") -> Create unknown angle, solid
+    - AngleSolid(value, "unit", "variable_name") -> Create known angle, solid
+
+    Examples:
+    ---------
+    >>> unknown = AngleSolid("pressure")  # Unknown angle, solid
+    >>> known = AngleSolid(100, "spat", "inlet_pressure")  # Known angle, solid
+
+    Available units: "spat", "square_degree", "square_gon"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AngleSolidSetter
+    _dimension = dim.ANGLE_SOLID
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AngleSolidSetter:
+        """
+        Create a setter for this angle, solid quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AngleSolidSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AngularAcceleration(FieldQnty):
+    """
+    Type-safe angular acceleration quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AngularAcceleration("variable_name") -> Create unknown angular acceleration
+    - AngularAcceleration(value, "unit", "variable_name") -> Create known angular acceleration
+
+    Examples:
+    ---------
+    >>> unknown = AngularAcceleration("pressure")  # Unknown angular acceleration
+    >>> known = AngularAcceleration(100, "radian_per_second_squared", "inlet_pressure")  # Known angular acceleration
+
+    Available units: "radian_per_second_squared", "revolution_per_second_squared", "rpm_or_revolution_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AngularAccelerationSetter
+    _dimension = dim.ANGULAR_ACCELERATION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AngularAccelerationSetter:
+        """
+        Create a setter for this angular acceleration quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AngularAccelerationSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AngularMomentum(FieldQnty):
+    """
+    Type-safe angular momentum quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AngularMomentum("variable_name") -> Create unknown angular momentum
+    - AngularMomentum(value, "unit", "variable_name") -> Create known angular momentum
+
+    Examples:
+    ---------
+    >>> unknown = AngularMomentum("pressure")  # Unknown angular momentum
+    >>> known = AngularMomentum(100, "gram_centimeter_squared_per_second", "inlet_pressure")  # Known angular momentum
+
+    Available units: "gram_centimeter_squared_per_second", "kilogram_meter_squared_per_second", "pound_force_square_foot_per_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AngularMomentumSetter
+    _dimension = dim.ANGULAR_MOMENTUM
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AngularMomentumSetter:
+        """
+        Create a setter for this angular momentum quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AngularMomentumSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Area(FieldQnty):
+    """
+    Type-safe area quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Area("variable_name") -> Create unknown area
+    - Area(value, "unit", "variable_name") -> Create known area
+
+    Examples:
+    ---------
+    >>> unknown = Area("pressure")  # Unknown area
+    >>> known = Area(100, "acre_general", "inlet_pressure")  # Known area
+
+    Available units: "acre_general", "are", "arpent_quebec"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AreaSetter
+    _dimension = dim.AREA
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AreaSetter:
+        """
+        Create a setter for this area quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AreaSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AreaPerUnitVolume(FieldQnty):
+    """
+    Type-safe area per unit volume quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AreaPerUnitVolume("variable_name") -> Create unknown area per unit volume
+    - AreaPerUnitVolume(value, "unit", "variable_name") -> Create known area per unit volume
+
+    Examples:
+    ---------
+    >>> unknown = AreaPerUnitVolume("pressure")  # Unknown area per unit volume
+    >>> known = AreaPerUnitVolume(100, "square_centimeter_per_cubic_centimeter", "inlet_pressure")  # Known area per unit volume
+
+    Available units: "square_centimeter_per_cubic_centimeter", "square_foot_per_cubic_foot", "square_inch_per_cubic_inch"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AreaPerUnitVolumeSetter
+    _dimension = dim.AREA_PER_UNIT_VOLUME
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AreaPerUnitVolumeSetter:
+        """
+        Create a setter for this area per unit volume quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AreaPerUnitVolumeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class AtomicWeight(FieldQnty):
+    """
+    Type-safe atomic weight quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - AtomicWeight("variable_name") -> Create unknown atomic weight
+    - AtomicWeight(value, "unit", "variable_name") -> Create known atomic weight
+
+    Examples:
+    ---------
+    >>> unknown = AtomicWeight("pressure")  # Unknown atomic weight
+    >>> known = AtomicWeight(100, "atomic_mass_unit_12c", "inlet_pressure")  # Known atomic weight
+
+    Available units: "atomic_mass_unit_12c", "grams_per_mole", "kilograms_per_kilomole"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.AtomicWeightSetter
+    _dimension = dim.ATOMIC_WEIGHT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.AtomicWeightSetter:
+        """
+        Create a setter for this atomic weight quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            AtomicWeightSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Concentration(FieldQnty):
+    """
+    Type-safe concentration quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Concentration("variable_name") -> Create unknown concentration
+    - Concentration(value, "unit", "variable_name") -> Create known concentration
+
+    Examples:
+    ---------
+    >>> unknown = Concentration("pressure")  # Unknown concentration
+    >>> known = Concentration(100, "grains_of_i_per_cubic_foot", "inlet_pressure")  # Known concentration
+
+    Available units: "grains_of_i_per_cubic_foot", "grains_of_i_per_gallon_us"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ConcentrationSetter
+    _dimension = dim.CONCENTRATION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ConcentrationSetter:
+        """
+        Create a setter for this concentration quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ConcentrationSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Dimensionless(FieldQnty):
+    """
+    Type-safe dimensionless quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Dimensionless("variable_name") -> Create unknown dimensionless
+    - Dimensionless(value, "variable_name") -> Create known dimensionless
+
+    Examples:
+    ---------
+    >>> unknown = Dimensionless("efficiency")  # Unknown dimensionless
+    >>> known = Dimensionless(0.85, "thermal_efficiency")  # Known dimensionless
+    """
+
+    __slots__ = ()
+    _setter_class = ts.DimensionlessSetter
+    _dimension = dim.DIMENSIONLESS
+
+    def __init__(self, name_or_value: str | int | float, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.DimensionlessSetter:
+        """
+        Create a setter for this dimensionless quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            DimensionlessSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class DynamicFluidity(FieldQnty):
+    """
+    Type-safe dynamic fluidity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - DynamicFluidity("variable_name") -> Create unknown dynamic fluidity
+    - DynamicFluidity(value, "unit", "variable_name") -> Create known dynamic fluidity
+
+    Examples:
+    ---------
+    >>> unknown = DynamicFluidity("pressure")  # Unknown dynamic fluidity
+    >>> known = DynamicFluidity(100, "meter_seconds_per_kilogram", "inlet_pressure")  # Known dynamic fluidity
+
+    Available units: "meter_seconds_per_kilogram", "rhe", "square_foot_per_pound_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.DynamicFluiditySetter
+    _dimension = dim.DYNAMIC_FLUIDITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.DynamicFluiditySetter:
+        """
+        Create a setter for this dynamic fluidity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            DynamicFluiditySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricCapacitance(FieldQnty):
+    """
+    Type-safe electric capacitance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricCapacitance("variable_name") -> Create unknown electric capacitance
+    - ElectricCapacitance(value, "unit", "variable_name") -> Create known electric capacitance
+
+    Examples:
+    ---------
+    >>> unknown = ElectricCapacitance("pressure")  # Unknown electric capacitance
+    >>> known = ElectricCapacitance(100, "cm", "inlet_pressure")  # Known electric capacitance
+
+    Available units: "cm", "abfarad", "farad"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricCapacitanceSetter
+    _dimension = dim.ELECTRIC_CAPACITANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricCapacitanceSetter:
+        """
+        Create a setter for this electric capacitance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricCapacitanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricCharge(FieldQnty):
+    """
+    Type-safe electric charge quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricCharge("variable_name") -> Create unknown electric charge
+    - ElectricCharge(value, "unit", "variable_name") -> Create known electric charge
+
+    Examples:
+    ---------
+    >>> unknown = ElectricCharge("pressure")  # Unknown electric charge
+    >>> known = ElectricCharge(100, "abcoulomb", "inlet_pressure")  # Known electric charge
+
+    Available units: "abcoulomb", "ampere_hour", "coulomb"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricChargeSetter
+    _dimension = dim.ELECTRIC_CHARGE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricChargeSetter:
+        """
+        Create a setter for this electric charge quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricChargeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricCurrentIntensity(FieldQnty):
+    """
+    Type-safe electric current intensity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricCurrentIntensity("variable_name") -> Create unknown electric current intensity
+    - ElectricCurrentIntensity(value, "unit", "variable_name") -> Create known electric current intensity
+
+    Examples:
+    ---------
+    >>> unknown = ElectricCurrentIntensity("pressure")  # Unknown electric current intensity
+    >>> known = ElectricCurrentIntensity(100, "abampere", "inlet_pressure")  # Known electric current intensity
+
+    Available units: "abampere", "ampere_intl_mean", "ampere_intl_us"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricCurrentIntensitySetter
+    _dimension = dim.ELECTRIC_CURRENT_INTENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricCurrentIntensitySetter:
+        """
+        Create a setter for this electric current intensity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricCurrentIntensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricDipoleMoment(FieldQnty):
+    """
+    Type-safe electric dipole moment quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricDipoleMoment("variable_name") -> Create unknown electric dipole moment
+    - ElectricDipoleMoment(value, "unit", "variable_name") -> Create known electric dipole moment
+
+    Examples:
+    ---------
+    >>> unknown = ElectricDipoleMoment("pressure")  # Unknown electric dipole moment
+    >>> known = ElectricDipoleMoment(100, "ampere_meter_second", "inlet_pressure")  # Known electric dipole moment
+
+    Available units: "ampere_meter_second", "coulomb_meter", "debye"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricDipoleMomentSetter
+    _dimension = dim.ELECTRIC_DIPOLE_MOMENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricDipoleMomentSetter:
+        """
+        Create a setter for this electric dipole moment quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricDipoleMomentSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricFieldStrength(FieldQnty):
+    """
+    Type-safe electric field strength quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricFieldStrength("variable_name") -> Create unknown electric field strength
+    - ElectricFieldStrength(value, "unit", "variable_name") -> Create known electric field strength
+
+    Examples:
+    ---------
+    >>> unknown = ElectricFieldStrength("pressure")  # Unknown electric field strength
+    >>> known = ElectricFieldStrength(100, "volt_per_centimeter", "inlet_pressure")  # Known electric field strength
+
+    Available units: "volt_per_centimeter", "volt_per_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricFieldStrengthSetter
+    _dimension = dim.ELECTRIC_FIELD_STRENGTH
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricFieldStrengthSetter:
+        """
+        Create a setter for this electric field strength quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricFieldStrengthSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricInductance(FieldQnty):
+    """
+    Type-safe electric inductance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricInductance("variable_name") -> Create unknown electric inductance
+    - ElectricInductance(value, "unit", "variable_name") -> Create known electric inductance
+
+    Examples:
+    ---------
+    >>> unknown = ElectricInductance("pressure")  # Unknown electric inductance
+    >>> known = ElectricInductance(100, "abhenry", "inlet_pressure")  # Known electric inductance
+
+    Available units: "abhenry", "cm", "henry"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricInductanceSetter
+    _dimension = dim.ELECTRIC_INDUCTANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricInductanceSetter:
+        """
+        Create a setter for this electric inductance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricInductanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricPotential(FieldQnty):
+    """
+    Type-safe electric potential quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricPotential("variable_name") -> Create unknown electric potential
+    - ElectricPotential(value, "unit", "variable_name") -> Create known electric potential
+
+    Examples:
+    ---------
+    >>> unknown = ElectricPotential("pressure")  # Unknown electric potential
+    >>> known = ElectricPotential(100, "abvolt", "inlet_pressure")  # Known electric potential
+
+    Available units: "abvolt", "statvolt", "u_a_potential"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricPotentialSetter
+    _dimension = dim.ELECTRIC_POTENTIAL
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricPotentialSetter:
+        """
+        Create a setter for this electric potential quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricPotentialSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricResistance(FieldQnty):
+    """
+    Type-safe electric resistance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricResistance("variable_name") -> Create unknown electric resistance
+    - ElectricResistance(value, "unit", "variable_name") -> Create known electric resistance
+
+    Examples:
+    ---------
+    >>> unknown = ElectricResistance("pressure")  # Unknown electric resistance
+    >>> known = ElectricResistance(100, "abohm", "inlet_pressure")  # Known electric resistance
+
+    Available units: "abohm", "jacobi", "lenz"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricResistanceSetter
+    _dimension = dim.ELECTRIC_RESISTANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricResistanceSetter:
+        """
+        Create a setter for this electric resistance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricResistanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricalConductance(FieldQnty):
+    """
+    Type-safe electrical conductance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricalConductance("variable_name") -> Create unknown electrical conductance
+    - ElectricalConductance(value, "unit", "variable_name") -> Create known electrical conductance
+
+    Examples:
+    ---------
+    >>> unknown = ElectricalConductance("pressure")  # Unknown electrical conductance
+    >>> known = ElectricalConductance(100, "emu_cgs", "inlet_pressure")  # Known electrical conductance
+
+    Available units: "emu_cgs", "esu_cgs", "mho"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricalConductanceSetter
+    _dimension = dim.ELECTRICAL_CONDUCTANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalConductanceSetter:
+        """
+        Create a setter for this electrical conductance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricalConductanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricalPermittivity(FieldQnty):
+    """
+    Type-safe electrical permittivity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricalPermittivity("variable_name") -> Create unknown electrical permittivity
+    - ElectricalPermittivity(value, "unit", "variable_name") -> Create known electrical permittivity
+
+    Examples:
+    ---------
+    >>> unknown = ElectricalPermittivity("pressure")  # Unknown electrical permittivity
+    >>> known = ElectricalPermittivity(100, "farad_per_meter", "inlet_pressure")  # Known electrical permittivity
+
+    Available units: "farad_per_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricalPermittivitySetter
+    _dimension = dim.ELECTRICAL_PERMITTIVITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalPermittivitySetter:
+        """
+        Create a setter for this electrical permittivity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricalPermittivitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ElectricalResistivity(FieldQnty):
+    """
+    Type-safe electrical resistivity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ElectricalResistivity("variable_name") -> Create unknown electrical resistivity
+    - ElectricalResistivity(value, "unit", "variable_name") -> Create known electrical resistivity
+
+    Examples:
+    ---------
+    >>> unknown = ElectricalResistivity("pressure")  # Unknown electrical resistivity
+    >>> known = ElectricalResistivity(100, "circular_mil_ohm_per_foot", "inlet_pressure")  # Known electrical resistivity
+
+    Available units: "circular_mil_ohm_per_foot", "emu_cgs", "microhm_inch"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ElectricalResistivitySetter
+    _dimension = dim.ELECTRICAL_RESISTIVITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalResistivitySetter:
+        """
+        Create a setter for this electrical resistivity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ElectricalResistivitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class EnergyFlux(FieldQnty):
+    """
+    Type-safe energy flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - EnergyFlux("variable_name") -> Create unknown energy flux
+    - EnergyFlux(value, "unit", "variable_name") -> Create known energy flux
+
+    Examples:
+    ---------
+    >>> unknown = EnergyFlux("pressure")  # Unknown energy flux
+    >>> known = EnergyFlux(100, "btu_per_square_foot_per_hour", "inlet_pressure")  # Known energy flux
+
+    Available units: "btu_per_square_foot_per_hour", "calorie_per_square_centimeter_per_second", "celsius_heat_units_chu"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.EnergyFluxSetter
+    _dimension = dim.ENERGY_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyFluxSetter:
+        """
+        Create a setter for this energy flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            EnergyFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class EnergyHeatWork(FieldQnty):
+    """
+    Type-safe energy, heat, work quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - EnergyHeatWork("variable_name") -> Create unknown energy, heat, work
+    - EnergyHeatWork(value, "unit", "variable_name") -> Create known energy, heat, work
+
+    Examples:
+    ---------
+    >>> unknown = EnergyHeatWork("pressure")  # Unknown energy, heat, work
+    >>> known = EnergyHeatWork(100, "barrel_oil_equivalent_or_equivalent_barrel", "inlet_pressure")  # Known energy, heat, work
+
+    Available units: "barrel_oil_equivalent_or_equivalent_barrel", "billion_electronvolt", "british_thermal_unit_4circ_mathrmc"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.EnergyHeatWorkSetter
+    _dimension = dim.ENERGY_HEAT_WORK
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyHeatWorkSetter:
+        """
+        Create a setter for this energy, heat, work quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            EnergyHeatWorkSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class EnergyPerUnitArea(FieldQnty):
+    """
+    Type-safe energy per unit area quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - EnergyPerUnitArea("variable_name") -> Create unknown energy per unit area
+    - EnergyPerUnitArea(value, "unit", "variable_name") -> Create known energy per unit area
+
+    Examples:
+    ---------
+    >>> unknown = EnergyPerUnitArea("pressure")  # Unknown energy per unit area
+    >>> known = EnergyPerUnitArea(100, "british_thermal_unit_per_square_foot", "inlet_pressure")  # Known energy per unit area
+
+    Available units: "british_thermal_unit_per_square_foot", "joule_per_square_meter", "langley"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.EnergyPerUnitAreaSetter
+    _dimension = dim.ENERGY_PER_UNIT_AREA
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyPerUnitAreaSetter:
+        """
+        Create a setter for this energy per unit area quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            EnergyPerUnitAreaSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Force(FieldQnty):
+    """
+    Type-safe force quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Force("variable_name") -> Create unknown force
+    - Force(value, "unit", "variable_name") -> Create known force
+
+    Examples:
+    ---------
+    >>> unknown = Force("pressure")  # Unknown force
+    >>> known = Force(100, "crinal", "inlet_pressure")  # Known force
+
+    Available units: "crinal", "dyne", "funal"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ForceSetter
+    _dimension = dim.FORCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ForceSetter:
+        """
+        Create a setter for this force quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ForceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ForceBody(FieldQnty):
+    """
+    Type-safe force (body) quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ForceBody("variable_name") -> Create unknown force (body)
+    - ForceBody(value, "unit", "variable_name") -> Create known force (body)
+
+    Examples:
+    ---------
+    >>> unknown = ForceBody("pressure")  # Unknown force (body)
+    >>> known = ForceBody(100, "dyne_per_cubic_centimeter", "inlet_pressure")  # Known force (body)
+
+    Available units: "dyne_per_cubic_centimeter", "kilogram_force_per_cubic_centimeter", "kilogram_force_per_cubic_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ForceBodySetter
+    _dimension = dim.FORCE_BODY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ForceBodySetter:
+        """
+        Create a setter for this force (body) quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ForceBodySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ForcePerUnitMass(FieldQnty):
+    """
+    Type-safe force per unit mass quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ForcePerUnitMass("variable_name") -> Create unknown force per unit mass
+    - ForcePerUnitMass(value, "unit", "variable_name") -> Create known force per unit mass
+
+    Examples:
+    ---------
+    >>> unknown = ForcePerUnitMass("pressure")  # Unknown force per unit mass
+    >>> known = ForcePerUnitMass(100, "dyne_per_gram", "inlet_pressure")  # Known force per unit mass
+
+    Available units: "dyne_per_gram", "kilogram_force_per_kilogram", "newton_per_kilogram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ForcePerUnitMassSetter
+    _dimension = dim.FORCE_PER_UNIT_MASS
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ForcePerUnitMassSetter:
+        """
+        Create a setter for this force per unit mass quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ForcePerUnitMassSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class FrequencyVoltageRatio(FieldQnty):
+    """
+    Type-safe frequency voltage ratio quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - FrequencyVoltageRatio("variable_name") -> Create unknown frequency voltage ratio
+    - FrequencyVoltageRatio(value, "unit", "variable_name") -> Create known frequency voltage ratio
+
+    Examples:
+    ---------
+    >>> unknown = FrequencyVoltageRatio("pressure")  # Unknown frequency voltage ratio
+    >>> known = FrequencyVoltageRatio(100, "cycles_per_second_per_volt", "inlet_pressure")  # Known frequency voltage ratio
+
+    Available units: "cycles_per_second_per_volt", "hertz_per_volt", "terahertz_per_volt"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.FrequencyVoltageRatioSetter
+    _dimension = dim.FREQUENCY_VOLTAGE_RATIO
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.FrequencyVoltageRatioSetter:
+        """
+        Create a setter for this frequency voltage ratio quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            FrequencyVoltageRatioSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class FuelConsumption(FieldQnty):
+    """
+    Type-safe fuel consumption quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - FuelConsumption("variable_name") -> Create unknown fuel consumption
+    - FuelConsumption(value, "unit", "variable_name") -> Create known fuel consumption
+
+    Examples:
+    ---------
+    >>> unknown = FuelConsumption("pressure")  # Unknown fuel consumption
+    >>> known = FuelConsumption(100, "unit_100_km_per_liter", "inlet_pressure")  # Known fuel consumption
+
+    Available units: "unit_100_km_per_liter", "gallons_uk", "gallons_us"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.FuelConsumptionSetter
+    _dimension = dim.FUEL_CONSUMPTION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.FuelConsumptionSetter:
+        """
+        Create a setter for this fuel consumption quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            FuelConsumptionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class HeatOfCombustion(FieldQnty):
+    """
+    Type-safe heat of combustion quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - HeatOfCombustion("variable_name") -> Create unknown heat of combustion
+    - HeatOfCombustion(value, "unit", "variable_name") -> Create known heat of combustion
+
+    Examples:
+    ---------
+    >>> unknown = HeatOfCombustion("pressure")  # Unknown heat of combustion
+    >>> known = HeatOfCombustion(100, "british_thermal_unit_per_pound", "inlet_pressure")  # Known heat of combustion
+
+    Available units: "british_thermal_unit_per_pound", "calorie_per_gram", "chu_per_pound"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.HeatOfCombustionSetter
+    _dimension = dim.HEAT_OF_COMBUSTION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfCombustionSetter:
+        """
+        Create a setter for this heat of combustion quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            HeatOfCombustionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class HeatOfFusion(FieldQnty):
+    """
+    Type-safe heat of fusion quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - HeatOfFusion("variable_name") -> Create unknown heat of fusion
+    - HeatOfFusion(value, "unit", "variable_name") -> Create known heat of fusion
+
+    Examples:
+    ---------
+    >>> unknown = HeatOfFusion("pressure")  # Unknown heat of fusion
+    >>> known = HeatOfFusion(100, "british_thermal_unit_mean", "inlet_pressure")  # Known heat of fusion
+
+    Available units: "british_thermal_unit_mean", "british_thermal_unit_per_pound", "calorie_per_gram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.HeatOfFusionSetter
+    _dimension = dim.HEAT_OF_FUSION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfFusionSetter:
+        """
+        Create a setter for this heat of fusion quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            HeatOfFusionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class HeatOfVaporization(FieldQnty):
+    """
+    Type-safe heat of vaporization quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - HeatOfVaporization("variable_name") -> Create unknown heat of vaporization
+    - HeatOfVaporization(value, "unit", "variable_name") -> Create known heat of vaporization
+
+    Examples:
+    ---------
+    >>> unknown = HeatOfVaporization("pressure")  # Unknown heat of vaporization
+    >>> known = HeatOfVaporization(100, "british_thermal_unit_per_pound", "inlet_pressure")  # Known heat of vaporization
+
+    Available units: "british_thermal_unit_per_pound", "calorie_per_gram", "chu_per_pound"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.HeatOfVaporizationSetter
+    _dimension = dim.HEAT_OF_VAPORIZATION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfVaporizationSetter:
+        """
+        Create a setter for this heat of vaporization quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            HeatOfVaporizationSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class HeatTransferCoefficient(FieldQnty):
+    """
+    Type-safe heat transfer coefficient quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - HeatTransferCoefficient("variable_name") -> Create unknown heat transfer coefficient
+    - HeatTransferCoefficient(value, "unit", "variable_name") -> Create known heat transfer coefficient
+
+    Examples:
+    ---------
+    >>> unknown = HeatTransferCoefficient("pressure")  # Unknown heat transfer coefficient
+    >>> known = HeatTransferCoefficient(100, "btu_per_square_foot_per_hour_per_degree_fahrenheit_or_rankine", "inlet_pressure")  # Known heat transfer coefficient
+
+    Available units: "btu_per_square_foot_per_hour_per_degree_fahrenheit_or_rankine", "watt_per_square_meter_per_degree_celsius_or_kelvin"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.HeatTransferCoefficientSetter
+    _dimension = dim.HEAT_TRANSFER_COEFFICIENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.HeatTransferCoefficientSetter:
+        """
+        Create a setter for this heat transfer coefficient quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            HeatTransferCoefficientSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Illuminance(FieldQnty):
+    """
+    Type-safe illuminance quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Illuminance("variable_name") -> Create unknown illuminance
+    - Illuminance(value, "unit", "variable_name") -> Create known illuminance
+
+    Examples:
+    ---------
+    >>> unknown = Illuminance("pressure")  # Unknown illuminance
+    >>> known = Illuminance(100, "foot_candle", "inlet_pressure")  # Known illuminance
+
+    Available units: "foot_candle", "lux", "nox"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.IlluminanceSetter
+    _dimension = dim.ILLUMINANCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.IlluminanceSetter:
+        """
+        Create a setter for this illuminance quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            IlluminanceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class KineticEnergyOfTurbulence(FieldQnty):
+    """
+    Type-safe kinetic energy of turbulence quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - KineticEnergyOfTurbulence("variable_name") -> Create unknown kinetic energy of turbulence
+    - KineticEnergyOfTurbulence(value, "unit", "variable_name") -> Create known kinetic energy of turbulence
+
+    Examples:
+    ---------
+    >>> unknown = KineticEnergyOfTurbulence("pressure")  # Unknown kinetic energy of turbulence
+    >>> known = KineticEnergyOfTurbulence(100, "square_foot_per_second_squared", "inlet_pressure")  # Known kinetic energy of turbulence
+
+    Available units: "square_foot_per_second_squared", "square_meters_per_second_squared"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.KineticEnergyOfTurbulenceSetter
+    _dimension = dim.KINETIC_ENERGY_OF_TURBULENCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.KineticEnergyOfTurbulenceSetter:
+        """
+        Create a setter for this kinetic energy of turbulence quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            KineticEnergyOfTurbulenceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Length(FieldQnty):
+    """
+    Type-safe length quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Length("variable_name") -> Create unknown length
+    - Length(value, "unit", "variable_name") -> Create known length
+
+    Examples:
+    ---------
+    >>> unknown = Length("pressure")  # Unknown length
+    >>> known = Length(100, "ngstr_m", "inlet_pressure")  # Known length
+
+    Available units: "ngstr_m", "arpent_quebec", "astronomic_unit"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LengthSetter
+    _dimension = dim.LENGTH
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LengthSetter:
+        """
+        Create a setter for this length quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LengthSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class LinearMassDensity(FieldQnty):
+    """
+    Type-safe linear mass density quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - LinearMassDensity("variable_name") -> Create unknown linear mass density
+    - LinearMassDensity(value, "unit", "variable_name") -> Create known linear mass density
+
+    Examples:
+    ---------
+    >>> unknown = LinearMassDensity("pressure")  # Unknown linear mass density
+    >>> known = LinearMassDensity(100, "denier", "inlet_pressure")  # Known linear mass density
+
+    Available units: "denier", "kilogram_per_centimeter", "kilogram_per_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LinearMassDensitySetter
+    _dimension = dim.LINEAR_MASS_DENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LinearMassDensitySetter:
+        """
+        Create a setter for this linear mass density quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LinearMassDensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class LinearMomentum(FieldQnty):
+    """
+    Type-safe linear momentum quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - LinearMomentum("variable_name") -> Create unknown linear momentum
+    - LinearMomentum(value, "unit", "variable_name") -> Create known linear momentum
+
+    Examples:
+    ---------
+    >>> unknown = LinearMomentum("pressure")  # Unknown linear momentum
+    >>> known = LinearMomentum(100, "foot_pounds_force_per_hour", "inlet_pressure")  # Known linear momentum
+
+    Available units: "foot_pounds_force_per_hour", "foot_pounds_force_per_minute", "foot_pounds_force_per_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LinearMomentumSetter
+    _dimension = dim.LINEAR_MOMENTUM
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LinearMomentumSetter:
+        """
+        Create a setter for this linear momentum quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LinearMomentumSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class LuminanceSelf(FieldQnty):
+    """
+    Type-safe luminance (self) quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - LuminanceSelf("variable_name") -> Create unknown luminance (self)
+    - LuminanceSelf(value, "unit", "variable_name") -> Create known luminance (self)
+
+    Examples:
+    ---------
+    >>> unknown = LuminanceSelf("pressure")  # Unknown luminance (self)
+    >>> known = LuminanceSelf(100, "apostilb", "inlet_pressure")  # Known luminance (self)
+
+    Available units: "apostilb", "blondel", "candela_per_square_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LuminanceSelfSetter
+    _dimension = dim.LUMINANCE_SELF
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LuminanceSelfSetter:
+        """
+        Create a setter for this luminance (self) quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LuminanceSelfSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class LuminousFlux(FieldQnty):
+    """
+    Type-safe luminous flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - LuminousFlux("variable_name") -> Create unknown luminous flux
+    - LuminousFlux(value, "unit", "variable_name") -> Create known luminous flux
+
+    Examples:
+    ---------
+    >>> unknown = LuminousFlux("pressure")  # Unknown luminous flux
+    >>> known = LuminousFlux(100, "candela_steradian", "inlet_pressure")  # Known luminous flux
+
+    Available units: "candela_steradian", "lumen"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LuminousFluxSetter
+    _dimension = dim.LUMINOUS_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LuminousFluxSetter:
+        """
+        Create a setter for this luminous flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LuminousFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class LuminousIntensity(FieldQnty):
+    """
+    Type-safe luminous intensity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - LuminousIntensity("variable_name") -> Create unknown luminous intensity
+    - LuminousIntensity(value, "unit", "variable_name") -> Create known luminous intensity
+
+    Examples:
+    ---------
+    >>> unknown = LuminousIntensity("pressure")  # Unknown luminous intensity
+    >>> known = LuminousIntensity(100, "candela", "inlet_pressure")  # Known luminous intensity
+
+    Available units: "candela", "candle_international", "carcel"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.LuminousIntensitySetter
+    _dimension = dim.LUMINOUS_INTENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.LuminousIntensitySetter:
+        """
+        Create a setter for this luminous intensity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            LuminousIntensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagneticField(FieldQnty):
+    """
+    Type-safe magnetic field quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagneticField("variable_name") -> Create unknown magnetic field
+    - MagneticField(value, "unit", "variable_name") -> Create known magnetic field
+
+    Examples:
+    ---------
+    >>> unknown = MagneticField("pressure")  # Unknown magnetic field
+    >>> known = MagneticField(100, "ampere_per_meter", "inlet_pressure")  # Known magnetic field
+
+    Available units: "ampere_per_meter", "lenz", "oersted"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagneticFieldSetter
+    _dimension = dim.MAGNETIC_FIELD
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticFieldSetter:
+        """
+        Create a setter for this magnetic field quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagneticFieldSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagneticFlux(FieldQnty):
+    """
+    Type-safe magnetic flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagneticFlux("variable_name") -> Create unknown magnetic flux
+    - MagneticFlux(value, "unit", "variable_name") -> Create known magnetic flux
+
+    Examples:
+    ---------
+    >>> unknown = MagneticFlux("pressure")  # Unknown magnetic flux
+    >>> known = MagneticFlux(100, "kapp_line", "inlet_pressure")  # Known magnetic flux
+
+    Available units: "kapp_line", "line", "maxwell"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagneticFluxSetter
+    _dimension = dim.MAGNETIC_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticFluxSetter:
+        """
+        Create a setter for this magnetic flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagneticFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagneticInductionFieldStrength(FieldQnty):
+    """
+    Type-safe magnetic induction field strength quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagneticInductionFieldStrength("variable_name") -> Create unknown magnetic induction field strength
+    - MagneticInductionFieldStrength(value, "unit", "variable_name") -> Create known magnetic induction field strength
+
+    Examples:
+    ---------
+    >>> unknown = MagneticInductionFieldStrength("pressure")  # Unknown magnetic induction field strength
+    >>> known = MagneticInductionFieldStrength(100, "gamma", "inlet_pressure")  # Known magnetic induction field strength
+
+    Available units: "gamma", "gauss", "line_per_square_centimeter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagneticInductionFieldStrengthSetter
+    _dimension = dim.MAGNETIC_INDUCTION_FIELD_STRENGTH
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticInductionFieldStrengthSetter:
+        """
+        Create a setter for this magnetic induction field strength quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagneticInductionFieldStrengthSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagneticMoment(FieldQnty):
+    """
+    Type-safe magnetic moment quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagneticMoment("variable_name") -> Create unknown magnetic moment
+    - MagneticMoment(value, "unit", "variable_name") -> Create known magnetic moment
+
+    Examples:
+    ---------
+    >>> unknown = MagneticMoment("pressure")  # Unknown magnetic moment
+    >>> known = MagneticMoment(100, "bohr_magneton", "inlet_pressure")  # Known magnetic moment
+
+    Available units: "bohr_magneton", "joule_per_tesla", "nuclear_magneton"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagneticMomentSetter
+    _dimension = dim.MAGNETIC_MOMENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticMomentSetter:
+        """
+        Create a setter for this magnetic moment quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagneticMomentSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagneticPermeability(FieldQnty):
+    """
+    Type-safe magnetic permeability quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagneticPermeability("variable_name") -> Create unknown magnetic permeability
+    - MagneticPermeability(value, "unit", "variable_name") -> Create known magnetic permeability
+
+    Examples:
+    ---------
+    >>> unknown = MagneticPermeability("pressure")  # Unknown magnetic permeability
+    >>> known = MagneticPermeability(100, "henrys_per_meter", "inlet_pressure")  # Known magnetic permeability
+
+    Available units: "henrys_per_meter", "newton_per_square_ampere"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagneticPermeabilitySetter
+    _dimension = dim.MAGNETIC_PERMEABILITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticPermeabilitySetter:
+        """
+        Create a setter for this magnetic permeability quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagneticPermeabilitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MagnetomotiveForce(FieldQnty):
+    """
+    Type-safe magnetomotive force quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MagnetomotiveForce("variable_name") -> Create unknown magnetomotive force
+    - MagnetomotiveForce(value, "unit", "variable_name") -> Create known magnetomotive force
+
+    Examples:
+    ---------
+    >>> unknown = MagnetomotiveForce("pressure")  # Unknown magnetomotive force
+    >>> known = MagnetomotiveForce(100, "abampere_turn", "inlet_pressure")  # Known magnetomotive force
+
+    Available units: "abampere_turn", "ampere", "ampere_turn"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MagnetomotiveForceSetter
+    _dimension = dim.MAGNETOMOTIVE_FORCE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MagnetomotiveForceSetter:
+        """
+        Create a setter for this magnetomotive force quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MagnetomotiveForceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Mass(FieldQnty):
+    """
+    Type-safe mass quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Mass("variable_name") -> Create unknown mass
+    - Mass(value, "unit", "variable_name") -> Create known mass
+
+    Examples:
+    ---------
+    >>> unknown = Mass("pressure")  # Unknown mass
+    >>> known = Mass(100, "slug", "inlet_pressure")  # Known mass
+
+    Available units: "slug", "atomic_mass_unit_12_mathrmc", "carat_metric"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassSetter
+    _dimension = dim.MASS
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassSetter:
+        """
+        Create a setter for this mass quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MassDensity(FieldQnty):
+    """
+    Type-safe mass density quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MassDensity("variable_name") -> Create unknown mass density
+    - MassDensity(value, "unit", "variable_name") -> Create known mass density
+
+    Examples:
+    ---------
+    >>> unknown = MassDensity("pressure")  # Unknown mass density
+    >>> known = MassDensity(100, "gram_per_cubic_centimeter", "inlet_pressure")  # Known mass density
+
+    Available units: "gram_per_cubic_centimeter", "gram_per_cubic_decimeter", "gram_per_cubic_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassDensitySetter
+    _dimension = dim.MASS_DENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassDensitySetter:
+        """
+        Create a setter for this mass density quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassDensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MassFlowRate(FieldQnty):
+    """
+    Type-safe mass flow rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MassFlowRate("variable_name") -> Create unknown mass flow rate
+    - MassFlowRate(value, "unit", "variable_name") -> Create known mass flow rate
+
+    Examples:
+    ---------
+    >>> unknown = MassFlowRate("pressure")  # Unknown mass flow rate
+    >>> known = MassFlowRate(100, "kilograms_per_day", "inlet_pressure")  # Known mass flow rate
+
+    Available units: "kilograms_per_day", "kilograms_per_hour", "kilograms_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassFlowRateSetter
+    _dimension = dim.MASS_FLOW_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassFlowRateSetter:
+        """
+        Create a setter for this mass flow rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MassFlux(FieldQnty):
+    """
+    Type-safe mass flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MassFlux("variable_name") -> Create unknown mass flux
+    - MassFlux(value, "unit", "variable_name") -> Create known mass flux
+
+    Examples:
+    ---------
+    >>> unknown = MassFlux("pressure")  # Unknown mass flux
+    >>> known = MassFlux(100, "kilogram_per_square_meter_per_day", "inlet_pressure")  # Known mass flux
+
+    Available units: "kilogram_per_square_meter_per_day", "kilogram_per_square_meter_per_hour", "kilogram_per_square_meter_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassFluxSetter
+    _dimension = dim.MASS_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassFluxSetter:
+        """
+        Create a setter for this mass flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MassFractionOfI(FieldQnty):
+    """
+    Type-safe mass fraction of "i" quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MassFractionOfI("variable_name") -> Create unknown mass fraction of "i"
+    - MassFractionOfI(value, "unit", "variable_name") -> Create known mass fraction of "i"
+
+    Examples:
+    ---------
+    >>> unknown = MassFractionOfI("pressure")  # Unknown mass fraction of "i"
+    >>> known = MassFractionOfI(100, "grains_of_i_per_pound_total", "inlet_pressure")  # Known mass fraction of "i"
+
+    Available units: "grains_of_i_per_pound_total", "gram_of_i_per_kilogram_total", "kilogram_of_i_per_kilogram_total"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassFractionOfISetter
+    _dimension = dim.MASS_FRACTION_OF_I
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassFractionOfISetter:
+        """
+        Create a setter for this mass fraction of "i" quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MassTransferCoefficient(FieldQnty):
+    """
+    Type-safe mass transfer coefficient quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MassTransferCoefficient("variable_name") -> Create unknown mass transfer coefficient
+    - MassTransferCoefficient(value, "unit", "variable_name") -> Create known mass transfer coefficient
+
+    Examples:
+    ---------
+    >>> unknown = MassTransferCoefficient("pressure")  # Unknown mass transfer coefficient
+    >>> known = MassTransferCoefficient(100, "gram_per_square_centimeter_per_second", "inlet_pressure")  # Known mass transfer coefficient
+
+    Available units: "gram_per_square_centimeter_per_second", "kilogram_per_square_meter_per_second", "pounds_force_per_cubic_foot_per_hour"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MassTransferCoefficientSetter
+    _dimension = dim.MASS_TRANSFER_COEFFICIENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MassTransferCoefficientSetter:
+        """
+        Create a setter for this mass transfer coefficient quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MassTransferCoefficientSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolalityOfSoluteI(FieldQnty):
+    """
+    Type-safe molality of solute "i" quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolalityOfSoluteI("variable_name") -> Create unknown molality of solute "i"
+    - MolalityOfSoluteI(value, "unit", "variable_name") -> Create known molality of solute "i"
+
+    Examples:
+    ---------
+    >>> unknown = MolalityOfSoluteI("pressure")  # Unknown molality of solute "i"
+    >>> known = MolalityOfSoluteI(100, "gram_moles_of_i_per_kilogram", "inlet_pressure")  # Known molality of solute "i"
+
+    Available units: "gram_moles_of_i_per_kilogram", "kilogram_mols_of_i_per_kilogram", "kmols_of_i_per_kilogram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolalityOfSoluteISetter
+    _dimension = dim.MOLALITY_OF_SOLUTE_I
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolalityOfSoluteISetter:
+        """
+        Create a setter for this molality of solute "i" quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolalityOfSoluteISetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolarConcentrationByMass(FieldQnty):
+    """
+    Type-safe molar concentration by mass quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolarConcentrationByMass("variable_name") -> Create unknown molar concentration by mass
+    - MolarConcentrationByMass(value, "unit", "variable_name") -> Create known molar concentration by mass
+
+    Examples:
+    ---------
+    >>> unknown = MolarConcentrationByMass("pressure")  # Unknown molar concentration by mass
+    >>> known = MolarConcentrationByMass(100, "gram_mole_or_mole_per_gram", "inlet_pressure")  # Known molar concentration by mass
+
+    Available units: "gram_mole_or_mole_per_gram", "gram_mole_or_mole_per_kilogram", "kilogram_mole_or_kmol_per_kilogram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolarConcentrationByMassSetter
+    _dimension = dim.MOLAR_CONCENTRATION_BY_MASS
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolarConcentrationByMassSetter:
+        """
+        Create a setter for this molar concentration by mass quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolarConcentrationByMassSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolarFlowRate(FieldQnty):
+    """
+    Type-safe molar flow rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolarFlowRate("variable_name") -> Create unknown molar flow rate
+    - MolarFlowRate(value, "unit", "variable_name") -> Create known molar flow rate
+
+    Examples:
+    ---------
+    >>> unknown = MolarFlowRate("pressure")  # Unknown molar flow rate
+    >>> known = MolarFlowRate(100, "gram_mole_per_day", "inlet_pressure")  # Known molar flow rate
+
+    Available units: "gram_mole_per_day", "gram_mole_per_hour", "gram_mole_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolarFlowRateSetter
+    _dimension = dim.MOLAR_FLOW_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolarFlowRateSetter:
+        """
+        Create a setter for this molar flow rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolarFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolarFlux(FieldQnty):
+    """
+    Type-safe molar flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolarFlux("variable_name") -> Create unknown molar flux
+    - MolarFlux(value, "unit", "variable_name") -> Create known molar flux
+
+    Examples:
+    ---------
+    >>> unknown = MolarFlux("pressure")  # Unknown molar flux
+    >>> known = MolarFlux(100, "kmol_per_square_meter_per_day", "inlet_pressure")  # Known molar flux
+
+    Available units: "kmol_per_square_meter_per_day", "kmol_per_square_meter_per_hour", "kmol_per_square_meter_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolarFluxSetter
+    _dimension = dim.MOLAR_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolarFluxSetter:
+        """
+        Create a setter for this molar flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolarFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolarHeatCapacity(FieldQnty):
+    """
+    Type-safe molar heat capacity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolarHeatCapacity("variable_name") -> Create unknown molar heat capacity
+    - MolarHeatCapacity(value, "unit", "variable_name") -> Create known molar heat capacity
+
+    Examples:
+    ---------
+    >>> unknown = MolarHeatCapacity("pressure")  # Unknown molar heat capacity
+    >>> known = MolarHeatCapacity(100, "btu_per_pound_mole_per_degree_fahrenheit_or_degree_rankine", "inlet_pressure")  # Known molar heat capacity
+
+    Available units: "btu_per_pound_mole_per_degree_fahrenheit_or_degree_rankine", "calories_per_gram_mole_per_kelvin_or_degree_celsius", "joule_per_gram_mole_per_kelvin_or_degree_celsius"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolarHeatCapacitySetter
+    _dimension = dim.MOLAR_HEAT_CAPACITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolarHeatCapacitySetter:
+        """
+        Create a setter for this molar heat capacity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolarHeatCapacitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MolarityOfI(FieldQnty):
+    """
+    Type-safe molarity of "i" quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MolarityOfI("variable_name") -> Create unknown molarity of "i"
+    - MolarityOfI(value, "unit", "variable_name") -> Create known molarity of "i"
+
+    Examples:
+    ---------
+    >>> unknown = MolarityOfI("pressure")  # Unknown molarity of "i"
+    >>> known = MolarityOfI(100, "gram_moles_of_i_per_cubic_meter", "inlet_pressure")  # Known molarity of "i"
+
+    Available units: "gram_moles_of_i_per_cubic_meter", "gram_moles_of_i_per_liter", "kilogram_moles_of_i_per_cubic_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MolarityOfISetter
+    _dimension = dim.MOLARITY_OF_I
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MolarityOfISetter:
+        """
+        Create a setter for this molarity of "i" quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MolarityOfISetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MoleFractionOfI(FieldQnty):
+    """
+    Type-safe mole fraction of "i" quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MoleFractionOfI("variable_name") -> Create unknown mole fraction of "i"
+    - MoleFractionOfI(value, "unit", "variable_name") -> Create known mole fraction of "i"
+
+    Examples:
+    ---------
+    >>> unknown = MoleFractionOfI("pressure")  # Unknown mole fraction of "i"
+    >>> known = MoleFractionOfI(100, "gram_mole_of_i_per_gram_mole_total", "inlet_pressure")  # Known mole fraction of "i"
+
+    Available units: "gram_mole_of_i_per_gram_mole_total", "kilogram_mole_of_i_per_kilogram_mole_total", "kilomole_of_i_per_kilomole_total"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MoleFractionOfISetter
+    _dimension = dim.MOLE_FRACTION_OF_I
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MoleFractionOfISetter:
+        """
+        Create a setter for this mole fraction of "i" quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MoleFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MomentOfInertia(FieldQnty):
+    """
+    Type-safe moment of inertia quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MomentOfInertia("variable_name") -> Create unknown moment of inertia
+    - MomentOfInertia(value, "unit", "variable_name") -> Create known moment of inertia
+
+    Examples:
+    ---------
+    >>> unknown = MomentOfInertia("pressure")  # Unknown moment of inertia
+    >>> known = MomentOfInertia(100, "gram_force_centimeter_square_second", "inlet_pressure")  # Known moment of inertia
+
+    Available units: "gram_force_centimeter_square_second", "gram_square_centimeter", "kilogram_force_centimeter_square_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MomentOfInertiaSetter
+    _dimension = dim.MOMENT_OF_INERTIA
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MomentOfInertiaSetter:
+        """
+        Create a setter for this moment of inertia quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MomentOfInertiaSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MomentumFlowRate(FieldQnty):
+    """
+    Type-safe momentum flow rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MomentumFlowRate("variable_name") -> Create unknown momentum flow rate
+    - MomentumFlowRate(value, "unit", "variable_name") -> Create known momentum flow rate
+
+    Examples:
+    ---------
+    >>> unknown = MomentumFlowRate("pressure")  # Unknown momentum flow rate
+    >>> known = MomentumFlowRate(100, "foot_pounds_per_square_hour", "inlet_pressure")  # Known momentum flow rate
+
+    Available units: "foot_pounds_per_square_hour", "foot_pounds_per_square_minute", "foot_pounds_per_square_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MomentumFlowRateSetter
+    _dimension = dim.MOMENTUM_FLOW_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MomentumFlowRateSetter:
+        """
+        Create a setter for this momentum flow rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MomentumFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class MomentumFlux(FieldQnty):
+    """
+    Type-safe momentum flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - MomentumFlux("variable_name") -> Create unknown momentum flux
+    - MomentumFlux(value, "unit", "variable_name") -> Create known momentum flux
+
+    Examples:
+    ---------
+    >>> unknown = MomentumFlux("pressure")  # Unknown momentum flux
+    >>> known = MomentumFlux(100, "dyne_per_square_centimeter", "inlet_pressure")  # Known momentum flux
+
+    Available units: "dyne_per_square_centimeter", "gram_per_centimeter_per_square_second", "newton_per_square_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.MomentumFluxSetter
+    _dimension = dim.MOMENTUM_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.MomentumFluxSetter:
+        """
+        Create a setter for this momentum flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            MomentumFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class NormalityOfSolution(FieldQnty):
+    """
+    Type-safe normality of solution quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - NormalityOfSolution("variable_name") -> Create unknown normality of solution
+    - NormalityOfSolution(value, "unit", "variable_name") -> Create known normality of solution
+
+    Examples:
+    ---------
+    >>> unknown = NormalityOfSolution("pressure")  # Unknown normality of solution
+    >>> known = NormalityOfSolution(100, "gram_equivalents_per_cubic_meter", "inlet_pressure")  # Known normality of solution
+
+    Available units: "gram_equivalents_per_cubic_meter", "gram_equivalents_per_liter", "pound_equivalents_per_cubic_foot"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.NormalityOfSolutionSetter
+    _dimension = dim.NORMALITY_OF_SOLUTION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.NormalityOfSolutionSetter:
+        """
+        Create a setter for this normality of solution quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            NormalityOfSolutionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ParticleDensity(FieldQnty):
+    """
+    Type-safe particle density quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ParticleDensity("variable_name") -> Create unknown particle density
+    - ParticleDensity(value, "unit", "variable_name") -> Create known particle density
+
+    Examples:
+    ---------
+    >>> unknown = ParticleDensity("pressure")  # Unknown particle density
+    >>> known = ParticleDensity(100, "particles_per_cubic_centimeter", "inlet_pressure")  # Known particle density
+
+    Available units: "particles_per_cubic_centimeter", "particles_per_cubic_foot", "particles_per_cubic_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ParticleDensitySetter
+    _dimension = dim.PARTICLE_DENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ParticleDensitySetter:
+        """
+        Create a setter for this particle density quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ParticleDensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Percent(FieldQnty):
+    """
+    Type-safe percent quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Percent("variable_name") -> Create unknown percent
+    - Percent(value, "unit", "variable_name") -> Create known percent
+
+    Examples:
+    ---------
+    >>> unknown = Percent("pressure")  # Unknown percent
+    >>> known = Percent(100, "percent", "inlet_pressure")  # Known percent
+
+    Available units: "percent", "per_mille", "basis_point"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PercentSetter
+    _dimension = dim.PERCENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PercentSetter:
+        """
+        Create a setter for this percent quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PercentSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Permeability(FieldQnty):
+    """
+    Type-safe permeability quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Permeability("variable_name") -> Create unknown permeability
+    - Permeability(value, "unit", "variable_name") -> Create known permeability
+
+    Examples:
+    ---------
+    >>> unknown = Permeability("pressure")  # Unknown permeability
+    >>> known = Permeability(100, "darcy", "inlet_pressure")  # Known permeability
+
+    Available units: "darcy", "square_feet", "square_meters"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PermeabilitySetter
+    _dimension = dim.PERMEABILITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PermeabilitySetter:
+        """
+        Create a setter for this permeability quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PermeabilitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class PhotonEmissionRate(FieldQnty):
+    """
+    Type-safe photon emission rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - PhotonEmissionRate("variable_name") -> Create unknown photon emission rate
+    - PhotonEmissionRate(value, "unit", "variable_name") -> Create known photon emission rate
+
+    Examples:
+    ---------
+    >>> unknown = PhotonEmissionRate("pressure")  # Unknown photon emission rate
+    >>> known = PhotonEmissionRate(100, "rayleigh", "inlet_pressure")  # Known photon emission rate
+
+    Available units: "rayleigh", "reciprocal_square_meter_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PhotonEmissionRateSetter
+    _dimension = dim.PHOTON_EMISSION_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PhotonEmissionRateSetter:
+        """
+        Create a setter for this photon emission rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PhotonEmissionRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class PowerPerUnitMass(FieldQnty):
+    """
+    Type-safe power per unit mass or specific power quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - PowerPerUnitMass("variable_name") -> Create unknown power per unit mass or specific power
+    - PowerPerUnitMass(value, "unit", "variable_name") -> Create known power per unit mass or specific power
+
+    Examples:
+    ---------
+    >>> unknown = PowerPerUnitMass("pressure")  # Unknown power per unit mass or specific power
+    >>> known = PowerPerUnitMass(100, "british_thermal_unit_per_hour_per_pound_mass", "inlet_pressure")  # Known power per unit mass or specific power
+
+    Available units: "british_thermal_unit_per_hour_per_pound_mass", "calorie_per_second_per_gram", "kilocalorie_per_hour_per_kilogram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PowerPerUnitMassSetter
+    _dimension = dim.POWER_PER_UNIT_MASS
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitMassSetter:
+        """
+        Create a setter for this power per unit mass or specific power quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PowerPerUnitMassSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class PowerPerUnitVolume(FieldQnty):
+    """
+    Type-safe power per unit volume or power density quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - PowerPerUnitVolume("variable_name") -> Create unknown power per unit volume or power density
+    - PowerPerUnitVolume(value, "unit", "variable_name") -> Create known power per unit volume or power density
+
+    Examples:
+    ---------
+    >>> unknown = PowerPerUnitVolume("pressure")  # Unknown power per unit volume or power density
+    >>> known = PowerPerUnitVolume(100, "british_thermal_unit_per_hour_per_cubic_foot", "inlet_pressure")  # Known power per unit volume or power density
+
+    Available units: "british_thermal_unit_per_hour_per_cubic_foot", "calorie_per_second_per_cubic_centimeter", "chu_per_hour_per_cubic_foot"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PowerPerUnitVolumeSetter
+    _dimension = dim.POWER_PER_UNIT_VOLUME
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitVolumeSetter:
+        """
+        Create a setter for this power per unit volume or power density quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PowerPerUnitVolumeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class PowerThermalDuty(FieldQnty):
+    """
+    Type-safe power, thermal duty quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - PowerThermalDuty("variable_name") -> Create unknown power, thermal duty
+    - PowerThermalDuty(value, "unit", "variable_name") -> Create known power, thermal duty
+
+    Examples:
+    ---------
+    >>> unknown = PowerThermalDuty("pressure")  # Unknown power, thermal duty
+    >>> known = PowerThermalDuty(100, "abwatt_emu_of_power", "inlet_pressure")  # Known power, thermal duty
+
+    Available units: "abwatt_emu_of_power", "boiler_horsepower", "british_thermal_unit_mean"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PowerThermalDutySetter
+    _dimension = dim.POWER_THERMAL_DUTY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PowerThermalDutySetter:
+        """
+        Create a setter for this power, thermal duty quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PowerThermalDutySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Pressure(FieldQnty):
+    """
+    Type-safe pressure quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Pressure("variable_name") -> Create unknown pressure
+    - Pressure(value, "unit", "variable_name") -> Create known pressure
+
+    Examples:
+    ---------
+    >>> unknown = Pressure("pressure")  # Unknown pressure
+    >>> known = Pressure(100, "atmosphere_standard", "inlet_pressure")  # Known pressure
+
+    Available units: "atmosphere_standard", "bar", "barye"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.PressureSetter
+    _dimension = dim.PRESSURE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.PressureSetter:
+        """
+        Create a setter for this pressure quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            PressureSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class RadiationDoseEquivalent(FieldQnty):
+    """
+    Type-safe radiation dose equivalent quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - RadiationDoseEquivalent("variable_name") -> Create unknown radiation dose equivalent
+    - RadiationDoseEquivalent(value, "unit", "variable_name") -> Create known radiation dose equivalent
+
+    Examples:
+    ---------
+    >>> unknown = RadiationDoseEquivalent("pressure")  # Unknown radiation dose equivalent
+    >>> known = RadiationDoseEquivalent(100, "rem", "inlet_pressure")  # Known radiation dose equivalent
+
+    Available units: "rem", "sievert", "millisievert"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.RadiationDoseEquivalentSetter
+    _dimension = dim.RADIATION_DOSE_EQUIVALENT
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.RadiationDoseEquivalentSetter:
+        """
+        Create a setter for this radiation dose equivalent quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            RadiationDoseEquivalentSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class RadiationExposure(FieldQnty):
+    """
+    Type-safe radiation exposure quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - RadiationExposure("variable_name") -> Create unknown radiation exposure
+    - RadiationExposure(value, "unit", "variable_name") -> Create known radiation exposure
+
+    Examples:
+    ---------
+    >>> unknown = RadiationExposure("pressure")  # Unknown radiation exposure
+    >>> known = RadiationExposure(100, "coulomb_per_kilogram", "inlet_pressure")  # Known radiation exposure
+
+    Available units: "coulomb_per_kilogram", "d_unit", "pastille_dose_b_unit"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.RadiationExposureSetter
+    _dimension = dim.RADIATION_EXPOSURE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.RadiationExposureSetter:
+        """
+        Create a setter for this radiation exposure quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            RadiationExposureSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Radioactivity(FieldQnty):
+    """
+    Type-safe radioactivity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Radioactivity("variable_name") -> Create unknown radioactivity
+    - Radioactivity(value, "unit", "variable_name") -> Create known radioactivity
+
+    Examples:
+    ---------
+    >>> unknown = Radioactivity("pressure")  # Unknown radioactivity
+    >>> known = Radioactivity(100, "becquerel", "inlet_pressure")  # Known radioactivity
+
+    Available units: "becquerel", "curie", "mache_unit"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.RadioactivitySetter
+    _dimension = dim.RADIOACTIVITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.RadioactivitySetter:
+        """
+        Create a setter for this radioactivity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            RadioactivitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SecondMomentOfArea(FieldQnty):
+    """
+    Type-safe second moment of area quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SecondMomentOfArea("variable_name") -> Create unknown second moment of area
+    - SecondMomentOfArea(value, "unit", "variable_name") -> Create known second moment of area
+
+    Examples:
+    ---------
+    >>> unknown = SecondMomentOfArea("pressure")  # Unknown second moment of area
+    >>> known = SecondMomentOfArea(100, "inch_quadrupled", "inlet_pressure")  # Known second moment of area
+
+    Available units: "inch_quadrupled", "centimeter_quadrupled", "foot_quadrupled"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SecondMomentOfAreaSetter
+    _dimension = dim.SECOND_MOMENT_OF_AREA
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SecondMomentOfAreaSetter:
+        """
+        Create a setter for this second moment of area quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SecondMomentOfAreaSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SecondRadiationConstantPlanck(FieldQnty):
+    """
+    Type-safe second radiation constant (planck) quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SecondRadiationConstantPlanck("variable_name") -> Create unknown second radiation constant (planck)
+    - SecondRadiationConstantPlanck(value, "unit", "variable_name") -> Create known second radiation constant (planck)
+
+    Examples:
+    ---------
+    >>> unknown = SecondRadiationConstantPlanck("pressure")  # Unknown second radiation constant (planck)
+    >>> known = SecondRadiationConstantPlanck(100, "meter_kelvin", "inlet_pressure")  # Known second radiation constant (planck)
+
+    Available units: "meter_kelvin"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SecondRadiationConstantPlanckSetter
+    _dimension = dim.SECOND_RADIATION_CONSTANT_PLANCK
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SecondRadiationConstantPlanckSetter:
+        """
+        Create a setter for this second radiation constant (planck) quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SecondRadiationConstantPlanckSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificEnthalpy(FieldQnty):
+    """
+    Type-safe specific enthalpy quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificEnthalpy("variable_name") -> Create unknown specific enthalpy
+    - SpecificEnthalpy(value, "unit", "variable_name") -> Create known specific enthalpy
+
+    Examples:
+    ---------
+    >>> unknown = SpecificEnthalpy("pressure")  # Unknown specific enthalpy
+    >>> known = SpecificEnthalpy(100, "british_thermal_unit_mean", "inlet_pressure")  # Known specific enthalpy
+
+    Available units: "british_thermal_unit_mean", "british_thermal_unit_per_pound", "calorie_per_gram"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificEnthalpySetter
+    _dimension = dim.SPECIFIC_ENTHALPY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificEnthalpySetter:
+        """
+        Create a setter for this specific enthalpy quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificEnthalpySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificGravity(FieldQnty):
+    """
+    Type-safe specific gravity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificGravity("variable_name") -> Create unknown specific gravity
+    - SpecificGravity(value, "unit", "variable_name") -> Create known specific gravity
+
+    Examples:
+    ---------
+    >>> unknown = SpecificGravity("pressure")  # Unknown specific gravity
+    >>> known = SpecificGravity(100, "dimensionless", "inlet_pressure")  # Known specific gravity
+
+    Available units: "dimensionless"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificGravitySetter
+    _dimension = dim.SPECIFIC_GRAVITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificGravitySetter:
+        """
+        Create a setter for this specific gravity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificGravitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificHeatCapacityConstantPressure(FieldQnty):
+    """
+    Type-safe specific heat capacity (constant pressure) quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificHeatCapacityConstantPressure("variable_name") -> Create unknown specific heat capacity (constant pressure)
+    - SpecificHeatCapacityConstantPressure(value, "unit", "variable_name") -> Create known specific heat capacity (constant pressure)
+
+    Examples:
+    ---------
+    >>> unknown = SpecificHeatCapacityConstantPressure("pressure")  # Unknown specific heat capacity (constant pressure)
+    >>> known = SpecificHeatCapacityConstantPressure(100, "btu_per_pound_per_degree_fahrenheit_or_degree_rankine", "inlet_pressure")  # Known specific heat capacity (constant pressure)
+
+    Available units: "btu_per_pound_per_degree_fahrenheit_or_degree_rankine", "calories_per_gram_per_kelvin_or_degree_celsius", "joules_per_kilogram_per_kelvin_or_degree_celsius"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificHeatCapacityConstantPressureSetter
+    _dimension = dim.SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificHeatCapacityConstantPressureSetter:
+        """
+        Create a setter for this specific heat capacity (constant pressure) quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificHeatCapacityConstantPressureSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificLength(FieldQnty):
+    """
+    Type-safe specific length quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificLength("variable_name") -> Create unknown specific length
+    - SpecificLength(value, "unit", "variable_name") -> Create known specific length
+
+    Examples:
+    ---------
+    >>> unknown = SpecificLength("pressure")  # Unknown specific length
+    >>> known = SpecificLength(100, "centimeter_per_gram", "inlet_pressure")  # Known specific length
+
+    Available units: "centimeter_per_gram", "cotton_count", "ft_per_pound"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificLengthSetter
+    _dimension = dim.SPECIFIC_LENGTH
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificLengthSetter:
+        """
+        Create a setter for this specific length quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificLengthSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificSurface(FieldQnty):
+    """
+    Type-safe specific surface quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificSurface("variable_name") -> Create unknown specific surface
+    - SpecificSurface(value, "unit", "variable_name") -> Create known specific surface
+
+    Examples:
+    ---------
+    >>> unknown = SpecificSurface("pressure")  # Unknown specific surface
+    >>> known = SpecificSurface(100, "square_centimeter_per_gram", "inlet_pressure")  # Known specific surface
+
+    Available units: "square_centimeter_per_gram", "square_foot_per_kilogram", "square_foot_per_pound"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificSurfaceSetter
+    _dimension = dim.SPECIFIC_SURFACE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificSurfaceSetter:
+        """
+        Create a setter for this specific surface quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificSurfaceSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SpecificVolume(FieldQnty):
+    """
+    Type-safe specific volume quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SpecificVolume("variable_name") -> Create unknown specific volume
+    - SpecificVolume(value, "unit", "variable_name") -> Create known specific volume
+
+    Examples:
+    ---------
+    >>> unknown = SpecificVolume("pressure")  # Unknown specific volume
+    >>> known = SpecificVolume(100, "cubic_centimeter_per_gram", "inlet_pressure")  # Known specific volume
+
+    Available units: "cubic_centimeter_per_gram", "cubic_foot_per_kilogram", "cubic_foot_per_pound"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SpecificVolumeSetter
+    _dimension = dim.SPECIFIC_VOLUME
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificVolumeSetter:
+        """
+        Create a setter for this specific volume quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SpecificVolumeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Stress(FieldQnty):
+    """
+    Type-safe stress quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Stress("variable_name") -> Create unknown stress
+    - Stress(value, "unit", "variable_name") -> Create known stress
+
+    Examples:
+    ---------
+    >>> unknown = Stress("pressure")  # Unknown stress
+    >>> known = Stress(100, "dyne_per_square_centimeter", "inlet_pressure")  # Known stress
+
+    Available units: "dyne_per_square_centimeter", "gigapascal", "hectopascal"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.StressSetter
+    _dimension = dim.STRESS
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.StressSetter:
+        """
+        Create a setter for this stress quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            StressSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SurfaceMassDensity(FieldQnty):
+    """
+    Type-safe surface mass density quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SurfaceMassDensity("variable_name") -> Create unknown surface mass density
+    - SurfaceMassDensity(value, "unit", "variable_name") -> Create known surface mass density
+
+    Examples:
+    ---------
+    >>> unknown = SurfaceMassDensity("pressure")  # Unknown surface mass density
+    >>> known = SurfaceMassDensity(100, "gram_per_square_centimeter", "inlet_pressure")  # Known surface mass density
+
+    Available units: "gram_per_square_centimeter", "gram_per_square_meter", "kilogram_per_square_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SurfaceMassDensitySetter
+    _dimension = dim.SURFACE_MASS_DENSITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SurfaceMassDensitySetter:
+        """
+        Create a setter for this surface mass density quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SurfaceMassDensitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class SurfaceTension(FieldQnty):
+    """
+    Type-safe surface tension quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - SurfaceTension("variable_name") -> Create unknown surface tension
+    - SurfaceTension(value, "unit", "variable_name") -> Create known surface tension
+
+    Examples:
+    ---------
+    >>> unknown = SurfaceTension("pressure")  # Unknown surface tension
+    >>> known = SurfaceTension(100, "dyne_per_centimeter", "inlet_pressure")  # Known surface tension
+
+    Available units: "dyne_per_centimeter", "gram_force_per_centimeter", "newton_per_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.SurfaceTensionSetter
+    _dimension = dim.SURFACE_TENSION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.SurfaceTensionSetter:
+        """
+        Create a setter for this surface tension quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            SurfaceTensionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Temperature(FieldQnty):
+    """
+    Type-safe temperature quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Temperature("variable_name") -> Create unknown temperature
+    - Temperature(value, "unit", "variable_name") -> Create known temperature
+
+    Examples:
+    ---------
+    >>> unknown = Temperature("pressure")  # Unknown temperature
+    >>> known = Temperature(100, "degree_celsius_unit_size", "inlet_pressure")  # Known temperature
+
+    Available units: "degree_celsius_unit_size", "degree_fahrenheit_unit_size", "degree_r_aumur_unit_size"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.TemperatureSetter
+    _dimension = dim.TEMPERATURE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.TemperatureSetter:
+        """
+        Create a setter for this temperature quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            TemperatureSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ThermalConductivity(FieldQnty):
+    """
+    Type-safe thermal conductivity quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ThermalConductivity("variable_name") -> Create unknown thermal conductivity
+    - ThermalConductivity(value, "unit", "variable_name") -> Create known thermal conductivity
+
+    Examples:
+    ---------
+    >>> unknown = ThermalConductivity("pressure")  # Unknown thermal conductivity
+    >>> known = ThermalConductivity(100, "btu_it", "inlet_pressure")  # Known thermal conductivity
+
+    Available units: "btu_it", "btu_therm", "btu_therm"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ThermalConductivitySetter
+    _dimension = dim.THERMAL_CONDUCTIVITY
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ThermalConductivitySetter:
+        """
+        Create a setter for this thermal conductivity quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ThermalConductivitySetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Time(FieldQnty):
+    """
+    Type-safe time quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Time("variable_name") -> Create unknown time
+    - Time(value, "unit", "variable_name") -> Create known time
+
+    Examples:
+    ---------
+    >>> unknown = Time("pressure")  # Unknown time
+    >>> known = Time(100, "blink", "inlet_pressure")  # Known time
+
+    Available units: "blink", "century", "chronon_or_tempon"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.TimeSetter
+    _dimension = dim.TIME
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.TimeSetter:
+        """
+        Create a setter for this time quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            TimeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Torque(FieldQnty):
+    """
+    Type-safe torque quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Torque("variable_name") -> Create unknown torque
+    - Torque(value, "unit", "variable_name") -> Create known torque
+
+    Examples:
+    ---------
+    >>> unknown = Torque("pressure")  # Unknown torque
+    >>> known = Torque(100, "centimeter_kilogram_force", "inlet_pressure")  # Known torque
+
+    Available units: "centimeter_kilogram_force", "dyne_centimeter", "foot_kilogram_force"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.TorqueSetter
+    _dimension = dim.TORQUE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.TorqueSetter:
+        """
+        Create a setter for this torque quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            TorqueSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class TurbulenceEnergyDissipationRate(FieldQnty):
+    """
+    Type-safe turbulence energy dissipation rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - TurbulenceEnergyDissipationRate("variable_name") -> Create unknown turbulence energy dissipation rate
+    - TurbulenceEnergyDissipationRate(value, "unit", "variable_name") -> Create known turbulence energy dissipation rate
+
+    Examples:
+    ---------
+    >>> unknown = TurbulenceEnergyDissipationRate("pressure")  # Unknown turbulence energy dissipation rate
+    >>> known = TurbulenceEnergyDissipationRate(100, "square_foot_per_cubic_second", "inlet_pressure")  # Known turbulence energy dissipation rate
+
+    Available units: "square_foot_per_cubic_second", "square_meter_per_cubic_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.TurbulenceEnergyDissipationRateSetter
+    _dimension = dim.TURBULENCE_ENERGY_DISSIPATION_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.TurbulenceEnergyDissipationRateSetter:
+        """
+        Create a setter for this turbulence energy dissipation rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            TurbulenceEnergyDissipationRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VelocityAngular(FieldQnty):
+    """
+    Type-safe velocity, angular quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VelocityAngular("variable_name") -> Create unknown velocity, angular
+    - VelocityAngular(value, "unit", "variable_name") -> Create known velocity, angular
+
+    Examples:
+    ---------
+    >>> unknown = VelocityAngular("pressure")  # Unknown velocity, angular
+    >>> known = VelocityAngular(100, "degree_per_minute", "inlet_pressure")  # Known velocity, angular
+
+    Available units: "degree_per_minute", "degree_per_second", "grade_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VelocityAngularSetter
+    _dimension = dim.VELOCITY_ANGULAR
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VelocityAngularSetter:
+        """
+        Create a setter for this velocity, angular quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VelocityAngularSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VelocityLinear(FieldQnty):
+    """
+    Type-safe velocity, linear quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VelocityLinear("variable_name") -> Create unknown velocity, linear
+    - VelocityLinear(value, "unit", "variable_name") -> Create known velocity, linear
+
+    Examples:
+    ---------
+    >>> unknown = VelocityLinear("pressure")  # Unknown velocity, linear
+    >>> known = VelocityLinear(100, "foot_per_hour", "inlet_pressure")  # Known velocity, linear
+
+    Available units: "foot_per_hour", "foot_per_minute", "foot_per_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VelocityLinearSetter
+    _dimension = dim.VELOCITY_LINEAR
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VelocityLinearSetter:
+        """
+        Create a setter for this velocity, linear quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VelocityLinearSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ViscosityDynamic(FieldQnty):
+    """
+    Type-safe viscosity, dynamic quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ViscosityDynamic("variable_name") -> Create unknown viscosity, dynamic
+    - ViscosityDynamic(value, "unit", "variable_name") -> Create known viscosity, dynamic
+
+    Examples:
+    ---------
+    >>> unknown = ViscosityDynamic("pressure")  # Unknown viscosity, dynamic
+    >>> known = ViscosityDynamic(100, "centipoise", "inlet_pressure")  # Known viscosity, dynamic
+
+    Available units: "centipoise", "dyne_second_per_square_centimeter", "kilopound_second_per_square_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ViscosityDynamicSetter
+    _dimension = dim.VISCOSITY_DYNAMIC
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ViscosityDynamicSetter:
+        """
+        Create a setter for this viscosity, dynamic quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ViscosityDynamicSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class ViscosityKinematic(FieldQnty):
+    """
+    Type-safe viscosity, kinematic quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - ViscosityKinematic("variable_name") -> Create unknown viscosity, kinematic
+    - ViscosityKinematic(value, "unit", "variable_name") -> Create known viscosity, kinematic
+
+    Examples:
+    ---------
+    >>> unknown = ViscosityKinematic("pressure")  # Unknown viscosity, kinematic
+    >>> known = ViscosityKinematic(100, "centistokes", "inlet_pressure")  # Known viscosity, kinematic
+
+    Available units: "centistokes", "millistokes", "square_centimeter_per_second"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.ViscosityKinematicSetter
+    _dimension = dim.VISCOSITY_KINEMATIC
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.ViscosityKinematicSetter:
+        """
+        Create a setter for this viscosity, kinematic quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            ViscosityKinematicSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Volume(FieldQnty):
+    """
+    Type-safe volume quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Volume("variable_name") -> Create unknown volume
+    - Volume(value, "unit", "variable_name") -> Create known volume
+
+    Examples:
+    ---------
+    >>> unknown = Volume("pressure")  # Unknown volume
+    >>> known = Volume(100, "acre_foot", "inlet_pressure")  # Known volume
+
+    Available units: "acre_foot", "acre_inch", "barrel_us_liquid"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumeSetter
+    _dimension = dim.VOLUME
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumeSetter:
+        """
+        Create a setter for this volume quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumeSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumeFractionOfI(FieldQnty):
+    """
+    Type-safe volume fraction of "i" quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumeFractionOfI("variable_name") -> Create unknown volume fraction of "i"
+    - VolumeFractionOfI(value, "unit", "variable_name") -> Create known volume fraction of "i"
+
+    Examples:
+    ---------
+    >>> unknown = VolumeFractionOfI("pressure")  # Unknown volume fraction of "i"
+    >>> known = VolumeFractionOfI(100, "cubic_centimeters_of_i_per_cubic_meter_total", "inlet_pressure")  # Known volume fraction of "i"
+
+    Available units: "cubic_centimeters_of_i_per_cubic_meter_total", "cubic_foot_of_i_per_cubic_foot_total", "cubic_meters_of_i_per_cubic_meter_total"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumeFractionOfISetter
+    _dimension = dim.VOLUME_FRACTION_OF_I
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumeFractionOfISetter:
+        """
+        Create a setter for this volume fraction of "i" quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumeFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumetricCalorificHeatingValue(FieldQnty):
+    """
+    Type-safe volumetric calorific (heating) value quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumetricCalorificHeatingValue("variable_name") -> Create unknown volumetric calorific (heating) value
+    - VolumetricCalorificHeatingValue(value, "unit", "variable_name") -> Create known volumetric calorific (heating) value
+
+    Examples:
+    ---------
+    >>> unknown = VolumetricCalorificHeatingValue("pressure")  # Unknown volumetric calorific (heating) value
+    >>> known = VolumetricCalorificHeatingValue(100, "british_thermal_unit_per_cubic_foot", "inlet_pressure")  # Known volumetric calorific (heating) value
+
+    Available units: "british_thermal_unit_per_cubic_foot", "british_thermal_unit_per_gallon_uk", "british_thermal_unit_per_gallon_us"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumetricCalorificHeatingValueSetter
+    _dimension = dim.VOLUMETRIC_CALORIFIC_HEATING_VALUE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCalorificHeatingValueSetter:
+        """
+        Create a setter for this volumetric calorific (heating) value quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumetricCalorificHeatingValueSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumetricCoefficientOfExpansion(FieldQnty):
+    """
+    Type-safe volumetric coefficient of expansion quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumetricCoefficientOfExpansion("variable_name") -> Create unknown volumetric coefficient of expansion
+    - VolumetricCoefficientOfExpansion(value, "unit", "variable_name") -> Create known volumetric coefficient of expansion
+
+    Examples:
+    ---------
+    >>> unknown = VolumetricCoefficientOfExpansion("pressure")  # Unknown volumetric coefficient of expansion
+    >>> known = VolumetricCoefficientOfExpansion(100, "gram_per_cubic_centimeter_per_kelvin_or_degree_celsius", "inlet_pressure")  # Known volumetric coefficient of expansion
+
+    Available units: "gram_per_cubic_centimeter_per_kelvin_or_degree_celsius", "kilogram_per_cubic_meter_per_kelvin_or_degree_celsius", "pound_per_cubic_foot_per_degree_fahrenheit_or_degree_rankine"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumetricCoefficientOfExpansionSetter
+    _dimension = dim.VOLUMETRIC_COEFFICIENT_OF_EXPANSION
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCoefficientOfExpansionSetter:
+        """
+        Create a setter for this volumetric coefficient of expansion quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumetricCoefficientOfExpansionSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumetricFlowRate(FieldQnty):
+    """
+    Type-safe volumetric flow rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumetricFlowRate("variable_name") -> Create unknown volumetric flow rate
+    - VolumetricFlowRate(value, "unit", "variable_name") -> Create known volumetric flow rate
+
+    Examples:
+    ---------
+    >>> unknown = VolumetricFlowRate("pressure")  # Unknown volumetric flow rate
+    >>> known = VolumetricFlowRate(100, "cubic_feet_per_day", "inlet_pressure")  # Known volumetric flow rate
+
+    Available units: "cubic_feet_per_day", "cubic_feet_per_hour", "cubic_feet_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumetricFlowRateSetter
+    _dimension = dim.VOLUMETRIC_FLOW_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFlowRateSetter:
+        """
+        Create a setter for this volumetric flow rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumetricFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumetricFlux(FieldQnty):
+    """
+    Type-safe volumetric flux quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumetricFlux("variable_name") -> Create unknown volumetric flux
+    - VolumetricFlux(value, "unit", "variable_name") -> Create known volumetric flux
+
+    Examples:
+    ---------
+    >>> unknown = VolumetricFlux("pressure")  # Unknown volumetric flux
+    >>> known = VolumetricFlux(100, "cubic_feet_per_square_foot_per_day", "inlet_pressure")  # Known volumetric flux
+
+    Available units: "cubic_feet_per_square_foot_per_day", "cubic_feet_per_square_foot_per_hour", "cubic_feet_per_square_foot_per_minute"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumetricFluxSetter
+    _dimension = dim.VOLUMETRIC_FLUX
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFluxSetter:
+        """
+        Create a setter for this volumetric flux quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumetricFluxSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class VolumetricMassFlowRate(FieldQnty):
+    """
+    Type-safe volumetric mass flow rate quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - VolumetricMassFlowRate("variable_name") -> Create unknown volumetric mass flow rate
+    - VolumetricMassFlowRate(value, "unit", "variable_name") -> Create known volumetric mass flow rate
+
+    Examples:
+    ---------
+    >>> unknown = VolumetricMassFlowRate("pressure")  # Unknown volumetric mass flow rate
+    >>> known = VolumetricMassFlowRate(100, "gram_per_second_per_cubic_centimeter", "inlet_pressure")  # Known volumetric mass flow rate
+
+    Available units: "gram_per_second_per_cubic_centimeter", "kilogram_per_hour_per_cubic_foot", "kilogram_per_hour_per_cubic_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.VolumetricMassFlowRateSetter
+    _dimension = dim.VOLUMETRIC_MASS_FLOW_RATE
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricMassFlowRateSetter:
+        """
+        Create a setter for this volumetric mass flow rate quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            VolumetricMassFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...
+
+class Wavenumber(FieldQnty):
+    """
+    Type-safe wavenumber quantity with expression capabilities.
+
+    Constructor Options:
+    -------------------
+    - Wavenumber("variable_name") -> Create unknown wavenumber
+    - Wavenumber(value, "unit", "variable_name") -> Create known wavenumber
+
+    Examples:
+    ---------
+    >>> unknown = Wavenumber("pressure")  # Unknown wavenumber
+    >>> known = Wavenumber(100, "diopter", "inlet_pressure")  # Known wavenumber
+
+    Available units: "diopter", "kayser", "reciprocal_meter"
+    """
+
+    __slots__ = ()
+    _setter_class = ts.WavenumberSetter
+    _dimension = dim.WAVENUMBER
+
+    def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True): ...
+    def set(self, value: float, unit: str | None = None) -> ts.WavenumberSetter:
+        """
+        Create a setter for this wavenumber quantity.
+
+        Args:
+            value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
+
+        Returns:
+            WavenumberSetter: A setter with unit properties like .meters, .inches, etc.
+
+        Example:
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
+        """
+        ...