open-space-toolkit-astrodynamics 15.6.0__py312-none-manylinux2014_aarch64.whl → 16.0.0__py312-none-manylinux2014_aarch64.whl

{open_space_toolkit_astrodynamics-15.6.0.dist-info → open_space_toolkit_astrodynamics-16.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: open-space-toolkit-astrodynamics
-Version: 15.6.0
+Version: 16.0.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_astrodynamics-15.6.0.dist-info → open_space_toolkit_astrodynamics-16.0.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-312-aarch64-linux-gnu.so,sha256=a6iqSVGznFAP9jKrpJNsuVZ0ZP9MmdEfi-2yNO7YPeA,2480296
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-312-aarch64-linux-gnu.so,sha256=lbY8rS2GUP8Kd8ttbDCcSgGG5V6-S6-pGBHWgFDnrvo,2533552
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/__init__.pyi,sha256=6ogKj5wREX8yV21bXaJgTPyhMHZ4OUEgZJETeAcFND4,31428
+ostk/astrodynamics/__init__.pyi,sha256=7m6On-qjnNorccVTHIVnbrri1AwqT65fAE0gouxfcjU,32193
 ostk/astrodynamics/access.pyi,sha256=t2CF0TU6_6ow_rkV_I4rVKap7ZIdC4jYKL3WkTDHRXg,25157
 ostk/astrodynamics/converters.py,sha256=luPh30qMp9bzEkN7hUccmxlLf7zRp_AzqmBe8IUjPhU,3314
 ostk/astrodynamics/converters.pyi,sha256=HrZFyizkc6Hv_K38ZKZ80fX_bAxd6keA_NFWNQygvbs,1745
@@ -9,9 +9,9 @@ ostk/astrodynamics/dataframe.py,sha256=v-36rBHKdf7kQw1jdvJWrvkR-ZjW5DKRchtTEJWhd
 ostk/astrodynamics/display.py,sha256=LZESZgx2wlrFO4cwAGMb3VPJfdtcjNgCgKFrqot0NYU,6339
 ostk/astrodynamics/dynamics.pyi,sha256=gZ95KoGex4SB-1z6yMrngkZN1Ir9X6bEmrZgdLxq1ZE,13270
 ostk/astrodynamics/estimator.pyi,sha256=MnahWzp8aACxrNKWlYRsgQr5zpBxogNr-yPm7hJob5k,14000
-ostk/astrodynamics/event_condition.pyi,sha256=LXvZCbKnX6kzES7iMG51lJRnIA64YFsU5mUY2RW9fkM,24798
+ostk/astrodynamics/event_condition.pyi,sha256=2c_1Sq7tkYKeAA_aRWBi43KDQXXxu6EMSmUpEWz_Fa4,45814
 ostk/astrodynamics/guidance_law.pyi,sha256=rVmbpV2Y5FsIXejaInxINS67nVHmTIxVEkhaDIn17SA,12171
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.15,sha256=ri_qOhWpo3qmfclGJC0RgjVaxNRBtCo2hAHiXPBbujA,3798552
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.16,sha256=vYKniNkCP03xaob_yvSqt9X36oinswZudb4upz1lSWc,3831176
 ostk/astrodynamics/solver.pyi,sha256=sPqyYPXBfFGC24dzzYyFyt01VfMAlWQ5_gh_RpeaBFk,17734
 ostk/astrodynamics/utilities.py,sha256=y8mr3M46J5z-GhS1oIEnuEJA6otwcyJ9YDhvn_5JxHM,6976
 ostk/astrodynamics/viewer.py,sha256=-Q4migLFOB9dNzs6TRPIXHNewyV5udsDSpcSma0kv8A,16376
@@ -37,7 +37,7 @@ ostk/astrodynamics/test/test_display.py,sha256=6giw_i08YMOSRgqNpdVWtzDu6fFalEVKz
 ostk/astrodynamics/test/test_event_condition.py,sha256=fQ-rVYpQsa7xacxRMBOQDyn61CuAGX1QBOGZxGWR0_s,2204
 ostk/astrodynamics/test/test_import.py,sha256=py_hALBR0IYuUzv9dfgQZzrrLHJIpnyKvt3Oi1XBqCg,1251
 ostk/astrodynamics/test/test_root_solver.py,sha256=hQ8O6g-WP49gZH_H3Rdufv0F0gQorpzJyIcjBGGUQ34,1831
-ostk/astrodynamics/test/test_trajectory.py,sha256=0sgGPkMFy-u-33z6SF-sTvaBb_NU7OvaeMTVF6wevfY,3148
+ostk/astrodynamics/test/test_trajectory.py,sha256=GzH7RNRiL088nFeeMm1lhpG4-HEFz15cnWcbD-8VAow,3933
 ostk/astrodynamics/test/test_utilities.py,sha256=NNIyzqOxMdsNpK2z0wU0utX06iZNfbMJDE36Upard28,3048
 ostk/astrodynamics/test/test_viewer.py,sha256=kDstRH_WKufN_0JPSXttzLMk3Afv_ylcEBfHxc35yrA,8946
 ostk/astrodynamics/test/access/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -62,7 +62,8 @@ ostk/astrodynamics/test/estimator/test_orbit_determination_solver.py,sha256=Vg_y
 ostk/astrodynamics/test/estimator/test_tle_solver.py,sha256=hANdRtaVvlOShXeyUqMpDk7kJINxdwstZodxJzAAWwk,7277
 ostk/astrodynamics/test/event_condition/test_angular_condition.py,sha256=MDRwjU5zXIRBaIFZA3jG3hcnyIIFo_0QyBRtNIfH2aQ,3119
 ostk/astrodynamics/test/event_condition/test_boolean_condition.py,sha256=Ng6FLKD8XoUHUz6-gi3wvrYhSGNSB_iJ_n89ajN4O3s,1580
-ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=AM0olK1s4jDRs_dJs0sk9raY9Nm1eZpdEEso6wyvipk,2580
+ostk/astrodynamics/test/event_condition/test_brouwer_lyddane_mean_long_condition.py,sha256=H5tXsj-oQRxaLS3CWvtFruUZp1LnvQGu4id3mBu4RJc,4440
+ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=dAADq0WEIcA-CvUyhH_6c917bwoaqCQ-XT_ru06Pcqc,4098
 ostk/astrodynamics/test/event_condition/test_instant_condition.py,sha256=Qr5dN6nrK7XDff7L4vnGCqasMK-Fa6qvxwy_U0xgH5M,1438
 ostk/astrodynamics/test/event_condition/test_logical_condition.py,sha256=09h5TYWtwGt4NQW3k_tziiVs0Q2981rNII9wyKg7p2Q,3321
 ostk/astrodynamics/test/event_condition/test_real_condition.py,sha256=tle6HVzMFMIIkfRY7CuaA0mPtw3riJBG_JQkc1L0dpk,1374
@@ -87,7 +88,7 @@ ostk/astrodynamics/test/trajectory/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nE
 ostk/astrodynamics/test/trajectory/test_orbit.py,sha256=vp7gDMtjO7nqERe0yq1OQZ0p4QRtxGTjGKN5-I3LWZM,6739
 ostk/astrodynamics/test/trajectory/test_propagator.py,sha256=ALjMvzndO9r6dVVXllk0iqu61tEoqu2j25MtzEitDIQ,14076
 ostk/astrodynamics/test/trajectory/test_segment.py,sha256=aXdF5CpNLwN_hKRU5sG3ID3hJR-NZ1_kgtNA-xHMBkM,12223
-ostk/astrodynamics/test/trajectory/test_sequence.py,sha256=iCNDDqEGoo4WZIOOov0qKGzrxjg7yWVIk8ajfKMhgI4,14503
+ostk/astrodynamics/test/trajectory/test_sequence.py,sha256=4piYpMZ9C_eCXxaOcdz2We67wZxhsNBnETgKwvq6dl0,15083
 ostk/astrodynamics/test/trajectory/test_state.py,sha256=th1BvTIhmgsPPFTbVnpR3URvqYFrf0oyluJyoPP7TPI,17135
 ostk/astrodynamics/test/trajectory/test_state_builder.py,sha256=LpCCYdCaLu_D2npm9wgA2sMlcekrtbRqP-afe5IE5L4,4871
 ostk/astrodynamics/test/trajectory/orbit/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -118,18 +119,18 @@ ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_attitude_quatern
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_acceleration.py,sha256=1p37_FYN85d9SrOqO3iCkNecovJJayhnFeZ4QCOw2ao,3528
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_position.py,sha256=XvHdk1KjacTwtkgx2jUAc9I9N3nvjPDv03FAanpv8jQ,2702
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_velocity.py,sha256=-kd5TZO5TICihbkqDTew2i_tDpggdpe3Yf23046FATM,3057
-ostk/astrodynamics/trajectory/__init__.pyi,sha256=sxwiGWbo6b4KgJFDUnz4YX2mn0__NXKMUhkWf-cq7q8,75487
+ostk/astrodynamics/trajectory/__init__.pyi,sha256=dxNnpdnDid4GRXiBs_Lr6WNn1L7jx42pwu_eq4Nk9Ss,76183
 ostk/astrodynamics/trajectory/orbit/__init__.pyi,sha256=wbuRK7Yp_NYBr3ta5-NpnJYMX4baUl7yIlUWhaRlR4o,12899
 ostk/astrodynamics/trajectory/orbit/message/__init__.pyi,sha256=-GNBlYPrsjelhKxWorYQYhIWzFsibiIQNZvMXjhRpfM,77
 ostk/astrodynamics/trajectory/orbit/message/spacex.pyi,sha256=fnUVJGWlSPo8AmLVuu08LubsAuVGo-gFaT86yd4f4CI,10558
 ostk/astrodynamics/trajectory/orbit/model/__init__.pyi,sha256=DYgjafm4rMV9Cqzg6dciwqsJdzuyE8JJgzW8up8qUeE,20370
 ostk/astrodynamics/trajectory/orbit/model/brouwerLyddaneMean.pyi,sha256=t1jbWsK8JgXkx-l_WSg96xfEG9fsddZ_CjqLpC3GBVY,5874
-ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=KZH_m7mqwXNKFTu4zLRMl_pG7ADQ9Zo6j3FYuVNnLwQ,26955
+ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=OZMznHuU7e6m1rfqtOgXbgBguimv4tg1RRvxRFQVAlw,27171
 ostk/astrodynamics/trajectory/orbit/model/sgp4.pyi,sha256=OhFzoPPQHlYy7m3LiZ8TXF89M4uBTfNk6tGsBEp0sjI,14235
 ostk/astrodynamics/trajectory/state/__init__.pyi,sha256=bq__Fii35czVrTeNxc9eQVjXdqwbbQxUdNQWK3vLrMo,17649
 ostk/astrodynamics/trajectory/state/coordinate_subset.pyi,sha256=kYMfMwEjCqO1NepMYFT4QS6kIPBkVL6sGCLeLbogcMw,10176
-open_space_toolkit_astrodynamics-15.6.0.dist-info/METADATA,sha256=5Nm6f5thffoDOhAlypysgUY8KnkhTGONPBbGR8LSJOI,1913
-open_space_toolkit_astrodynamics-15.6.0.dist-info/WHEEL,sha256=R5pNgnt8b9fXaDTmvusPEx11BdzBXjt30_JyyExPv08,111
-open_space_toolkit_astrodynamics-15.6.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-15.6.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-15.6.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-16.0.0.dist-info/METADATA,sha256=QZzoZmh6ksKVxnXob_SRtfRykp2hf20s2fLMk70AXtk,1913
+open_space_toolkit_astrodynamics-16.0.0.dist-info/WHEEL,sha256=R5pNgnt8b9fXaDTmvusPEx11BdzBXjt30_JyyExPv08,111
+open_space_toolkit_astrodynamics-16.0.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-16.0.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-16.0.0.dist-info/RECORD,,

ostk/astrodynamics/__init__.pyi

@@ -19,15 +19,15 @@ from ostk import physics as OpenSpaceToolkitPhysicsPy
 from ostk.physics import Environment
 from ostk.physics import Manager
 from ostk.physics import Unit
-from ostk.physics import coordinate
 import ostk.physics.coordinate
+from ostk.physics import coordinate
 import ostk.physics.coordinate.spherical
 from ostk.physics import environment
 import ostk.physics.environment.object
 import ostk.physics.time
 from ostk.physics import time
-from ostk.physics import unit
 import ostk.physics.unit
+from ostk.physics import unit
 import typing
 from . import access
 from . import conjunction
@@ -672,6 +672,19 @@ class Trajectory:
                             Trajectory: The `Trajectory` object representing the ground strip.
         """
     @staticmethod
+    def ground_strip_geodetic_nadir(orbit: typing.Any, instants: list[ostk.physics.time.Instant], celestial_object: ostk.physics.environment.object.Celestial = ...) -> Trajectory:
+        """
+                        Create a `Trajectory` object representing a ground strip that follows the geodetic nadir of the provided orbit.
+        
+                        Args:
+                            orbit (Orbit): The orbit.
+                            instants (list[Instant]): The instants.
+                            celestial_object (Celestial): The celestial object. Defaults to Earth.WGS84().
+        
+                        Returns:
+                            Trajectory: The `Trajectory` object representing the ground strip.  
+        """
+    @staticmethod
     def position(position: ostk.physics.coordinate.Position) -> Trajectory:
         """
                         Create a `Trajectory` object representing a position.

ostk/astrodynamics/event_condition.pyi

@@ -6,7 +6,7 @@ import ostk.physics.coordinate
 import ostk.physics.time
 import ostk.physics.unit
 import typing
-__all__ = ['AngularCondition', 'BooleanCondition', 'COECondition', 'InstantCondition', 'LogicalCondition', 'RealCondition']
+__all__ = ['AngularCondition', 'BooleanCondition', 'BrouwerLyddaneMeanLongCondition', 'COECondition', 'InstantCondition', 'LogicalCondition', 'RealCondition']
 class AngularCondition(ostk.astrodynamics.EventCondition):
     """
     
@@ -193,6 +193,244 @@ class BooleanCondition(RealCondition):
                         Returns:
                             bool: True if the condition is satisfied, False otherwise.
         """
+class BrouwerLyddaneMeanLongCondition:
+    """
+    
+                    A Brouwer-Lyddane Mean Long Event Condition.
+    
+                
+    """
+    @staticmethod
+    @typing.overload
+    def aop(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, aop: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of perigee.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                aop (EventConditionTarget): The argument of perigee.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def aop(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of perigee being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, argument_of_latitude: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of latitude.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                argument_of_latitude (EventConditionTarget): The argument of latitude.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of latitude being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentric_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentric anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                eccentric_anomaly (EventConditionTarget): The eccentric anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentric anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    def eccentricity(criterion: RealCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentricity: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> RealCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentricity.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                eccentricity (EventConditionTarget): The eccentricity.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, inclination: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the inclination.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                inclination (EventConditionTarget): The inclination.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the inclination being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def mean_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, mean_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the mean anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                mean_anomaly (EventConditionTarget): The mean anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def mean_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the mean anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, raan: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the right ascension of the ascending node.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                raan (EventConditionTarget): The right ascension of the ascending node.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the right ascension of the ascending node being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    def semi_major_axis(criterion: RealCondition.Criterion, frame: ostk.physics.coordinate.Frame, semi_major_axis: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> RealCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the semi-major axis.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                semi_major_axis (EventConditionTarget): The semi-major axis.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, true_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the true anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                true_anomaly (EventConditionTarget): The true anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the true anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
 class COECondition:
     """
     
@@ -201,6 +439,7 @@ class COECondition:
                 
     """
     @staticmethod
+    @typing.overload
     def aop(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, aop: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the argument of perigee.
@@ -209,12 +448,56 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 aop (EventConditionTarget): The argument of perigee.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def aop(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of perigee being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, argument_of_latitude: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of latitude.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                argument_of_latitude (EventConditionTarget): The argument of latitude.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
+    def argument_of_latitude(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of latitude being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
     def eccentric_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentric_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the eccentric anomaly.
@@ -223,7 +506,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 eccentric_anomaly (EventConditionTarget): The eccentric anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the eccentric anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
@@ -237,12 +534,13 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 eccentricity (EventConditionTarget): The eccentricity.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def inclination(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, inclination: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the inclination.
@@ -251,12 +549,27 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 inclination (EventConditionTarget): The inclination.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the inclination being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def mean_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, mean_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the mean anomaly.
@@ -265,12 +578,27 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 mean_anomaly (EventConditionTarget): The mean anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
+    def mean_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the mean anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
     def raan(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, raan: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the right ascension of the ascending node.
@@ -279,7 +607,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 raan (EventConditionTarget): The right ascension of the ascending node.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the right ascension of the ascending node being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
@@ -293,12 +635,13 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 semi_major_axis (EventConditionTarget): The semi-major axis.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def true_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, true_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the true anomaly.
@@ -307,7 +650,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 true_anomaly (EventConditionTarget): The true anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the true anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.

ostk/astrodynamics/test/event_condition/test_brouwer_lyddane_mean_long_condition.py

@@ -0,0 +1,135 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.unit import Derived, Length, Angle
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.event_condition import (
+    BrouwerLyddaneMeanLongCondition,
+    AngularCondition,
+    RealCondition,
+)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.AnyCrossing
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Earth.spherical.gravitational_parameter
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+class TestBrouwerLyddaneMeanLongCondition:
+    @pytest.mark.parametrize(
+        "static_constructor,target,criterion",
+        (
+            (
+                BrouwerLyddaneMeanLongCondition.semi_major_axis,
+                EventCondition.Target(Length.meters(7e6)),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentricity,
+                EventCondition.Target(0.1),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.inclination,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.aop,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.raan,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.true_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.mean_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentric_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.argument_of_latitude,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+        ),
+    )
+    def test_static_constructors(
+        self,
+        static_constructor,
+        target,
+        criterion,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(criterion, frame, target, gravitational_parameter)
+        assert condition is not None
+
+    @pytest.mark.parametrize(
+        "static_constructor,target_range",
+        (
+            (
+                BrouwerLyddaneMeanLongCondition.inclination,
+                (Angle.degrees(10.0), Angle.degrees(20.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.aop,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.raan,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.true_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.mean_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentric_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.argument_of_latitude,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+        ),
+    )
+    def test_static_constructors_within_range(
+        self,
+        static_constructor,
+        target_range,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(frame, target_range, gravitational_parameter)
+        assert condition is not None

ostk/astrodynamics/test/event_condition/test_coe_condition.py

@@ -73,6 +73,11 @@ class TestCOECondition:
                 EventCondition.Target(Angle.degrees(0.0)),
                 AngularCondition.Criterion.PositiveCrossing,
             ),
+            (
+                COECondition.argument_of_latitude,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
         ),
     )
     def test_static_constructors(
@@ -85,3 +90,46 @@ class TestCOECondition:
     ):
         condition = static_constructor(criterion, frame, target, gravitational_parameter)
         assert condition is not None
+
+    @pytest.mark.parametrize(
+        "static_constructor,target_range",
+        (
+            (
+                COECondition.inclination,
+                (Angle.degrees(10.0), Angle.degrees(20.0)),
+            ),
+            (
+                COECondition.aop,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.raan,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.true_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.mean_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.eccentric_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.argument_of_latitude,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+        ),
+    )
+    def test_static_constructors_within_range(
+        self,
+        static_constructor,
+        target_range,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(frame, target_range, gravitational_parameter)
+        assert condition is not None

ostk/astrodynamics/test/test_trajectory.py

@@ -9,9 +9,12 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.time import Instant
 from ostk.physics.time import Duration
 from ostk.physics.unit import Derived
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics import Trajectory
 from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
 
 
 @pytest.fixture
@@ -61,6 +64,16 @@ def states(trajectory: Trajectory) -> list[State]:
     )
 
 
+@pytest.fixture
+def orbit() -> Orbit:
+    return Orbit.circular(
+        epoch=Instant.J2000(),
+        altitude=Length.meters(545000.0),
+        inclination=Angle.degrees(0.0),
+        celestial_object=Earth.WGS84(),
+    )
+
+
 class TestTrajectory:
     def test_trajectory(self, states: list[State]):
         assert Trajectory(states) is not None
@@ -116,3 +129,17 @@ class TestTrajectory:
 
         assert Trajectory.ground_strip(start_lla, end_lla, instants, earth) is not None
         assert Trajectory.ground_strip(start_lla, end_lla, instants) is not None
+
+    def test_ground_strip_geodetic_nadir(
+        self, orbit: Orbit, instants: list[Instant], earth: Earth
+    ):
+        assert (
+            Trajectory.ground_strip_geodetic_nadir(
+                orbit=orbit, instants=instants, celestial_object=earth
+            )
+            is not None
+        )
+        assert (
+            Trajectory.ground_strip_geodetic_nadir(orbit=orbit, instants=instants)
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_sequence.py

@@ -156,17 +156,7 @@ def state(
 
     return State(
         instant,
-        [
-            717094.039086306,
-            -6872433.2241124,
-            46175.9696673281,
-            -970.650826004612,
-            -45.4598114773158,
-            7529.82424886455,
-            dry_mass.in_kilograms() + wet_mass.in_kilograms(),
-            cross_sectional_surface_area,
-            drag_coefficient,
-        ],
+        coordinates,
         frame,
         coordinate_broker,
     )
@@ -351,6 +341,28 @@ def sequence_solution(
     )
 
 
+@pytest.fixture
+def minimum_maneuver_duration():
+    return Duration.minutes(1.0)
+
+
+@pytest.fixture
+def sequence_with_minimum_maneuver_duration(
+    segments: list[Segment],
+    numerical_solver: NumericalSolver,
+    dynamics: list,
+    maximum_propagation_duration: Duration,
+    minimum_maneuver_duration: Duration,
+):
+    return Sequence(
+        segments=segments,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        maximum_propagation_duration=maximum_propagation_duration,
+        minimum_maneuver_duration=minimum_maneuver_duration,
+    )
+
+
 class TestSequenceSolution:
     def test_properties(
         self,
@@ -421,6 +433,16 @@ class TestSequence:
     ):
         assert sequence.get_maximum_propagation_duration() == maximum_propagation_duration
 
+    def test_get_minimum_maneuver_duration(
+        self,
+        sequence_with_minimum_maneuver_duration: Sequence,
+        minimum_maneuver_duration: Duration,
+    ):
+        assert (
+            sequence_with_minimum_maneuver_duration.get_minimum_maneuver_duration()
+            == minimum_maneuver_duration
+        )
+
     def test_add_segment(
         self,
         sequence: Sequence,

ostk/astrodynamics/trajectory/__init__.pyi

@@ -1270,16 +1270,17 @@ class Sequence:
             
                             :type: list[SegmentSolution]
             """
-    def __init__(self: typing.Sequence, segments: list[Segment] = [], numerical_solver: state.NumericalSolver = ..., dynamics: list[...] = [], maximum_propagation_duration: ostk.physics.time.Duration = ..., verbosity: int = 1) -> None:
+    def __init__(self: typing.Sequence, segments: list[Segment] = [], numerical_solver: state.NumericalSolver = ..., dynamics: list[...] = [], maximum_propagation_duration: ostk.physics.time.Duration = ..., minimum_maneuver_duration: ostk.physics.time.Duration = ..., verbosity: int = 1) -> None:
         """
                             Construct a new `Sequence` object.
         
                             Args:
-                            segments (list[Segment], optional): The segments.
-                            numerical_solver (NumericalSolver, optional): The numerical solver.
-                            dynamics (list[Dynamics], optional): The dynamics.
-                            maximum_propagation_duration (Duration, optional): The maximum propagation duration.
-                            verbosity (int, optional): The verbosity level.
+                            segments (list[Segment], optional): The segments. Defaults to an empty list.
+                            numerical_solver (NumericalSolver, optional): The numerical solver. Defaults to the default conditional numerical solver.
+                            dynamics (list[Dynamics], optional): The dynamics. Defaults to an empty list.
+                            maximum_propagation_duration (Duration, optional): The maximum propagation duration. Defaults to 30 days.
+                            minimum_maneuver_duration (Duration, optional): The minimum maneuver duration. Defaults to Undefined. If defined, maneuvers less than this duration will be skipped.
+                            verbosity (int, optional): The verbosity level. Defaults to 1.
         
                             Returns:
                                 Sequence: The new `Sequence` object.
@@ -1331,6 +1332,13 @@ class Sequence:
                             Returns:
                                 Duration: The maximum propagation duration.
         """
+    def get_minimum_maneuver_duration(self: typing.Sequence) -> ostk.physics.time.Duration:
+        """
+                            Get the minimum maneuver duration.
+        
+                            Returns:
+                                Duration: The minimum maneuver duration.
+        """
     def get_numerical_solver(self: typing.Sequence) -> state.NumericalSolver:
         """
                             Get the numerical solver.

ostk/astrodynamics/trajectory/orbit/model/kepler.pyi

@@ -100,8 +100,11 @@ class COE:
           MeanAnomaly : Mean Anomaly
         
           EccentricAnomaly : Eccentric Anomaly
+        
+          ArgumentOfLatitude : Argument of Latitude
         """
         Aop: typing.ClassVar[COE.Element]  # value = <Element.Aop: 4>
+        ArgumentOfLatitude: typing.ClassVar[COE.Element]  # value = <Element.ArgumentOfLatitude: 8>
         EccentricAnomaly: typing.ClassVar[COE.Element]  # value = <Element.EccentricAnomaly: 7>
         Eccentricity: typing.ClassVar[COE.Element]  # value = <Element.Eccentricity: 1>
         Inclination: typing.ClassVar[COE.Element]  # value = <Element.Inclination: 2>
@@ -109,7 +112,7 @@ class COE:
         Raan: typing.ClassVar[COE.Element]  # value = <Element.Raan: 3>
         SemiMajorAxis: typing.ClassVar[COE.Element]  # value = <Element.SemiMajorAxis: 0>
         TrueAnomaly: typing.ClassVar[COE.Element]  # value = <Element.TrueAnomaly: 5>
-        __members__: typing.ClassVar[dict[str, COE.Element]]  # value = {'SemiMajorAxis': <Element.SemiMajorAxis: 0>, 'Eccentricity': <Element.Eccentricity: 1>, 'Inclination': <Element.Inclination: 2>, 'Aop': <Element.Aop: 4>, 'Raan': <Element.Raan: 3>, 'TrueAnomaly': <Element.TrueAnomaly: 5>, 'MeanAnomaly': <Element.MeanAnomaly: 6>, 'EccentricAnomaly': <Element.EccentricAnomaly: 7>}
+        __members__: typing.ClassVar[dict[str, COE.Element]]  # value = {'SemiMajorAxis': <Element.SemiMajorAxis: 0>, 'Eccentricity': <Element.Eccentricity: 1>, 'Inclination': <Element.Inclination: 2>, 'Aop': <Element.Aop: 4>, 'Raan': <Element.Raan: 3>, 'TrueAnomaly': <Element.TrueAnomaly: 5>, 'MeanAnomaly': <Element.MeanAnomaly: 6>, 'EccentricAnomaly': <Element.EccentricAnomaly: 7>, 'ArgumentOfLatitude': <Element.ArgumentOfLatitude: 8>}
         def __eq__(self, other: typing.Any) -> bool:
             ...
         def __getstate__(self) -> int: