# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
# SPDX-License-Identifier: MIT
#
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

"""Object Model components specifically designed to support STK Astrogator."""

__all__ = ["AccessCriterion", "AccessStoppingCondition", "AsTriggerCondition", "AscentType", "AtmosphereDataSource",
"AttitudeControl", "AttitudeControlFiniteAntiVelocityVector", "AttitudeControlFiniteAttitude",
"AttitudeControlFiniteFile", "AttitudeControlFinitePlugin", "AttitudeControlFiniteThrustVector",
"AttitudeControlFiniteTimeVarying", "AttitudeControlFiniteVelocityVector", "AttitudeControlImpulsiveAntiVelocityVector",
"AttitudeControlImpulsiveAttitude", "AttitudeControlImpulsiveFile", "AttitudeControlImpulsiveThrustVector",
"AttitudeControlImpulsiveVelocityVector", "AttitudeControlOptimalFiniteLagrange", "AttitudeUpdate", "AutomaticSequence",
"AutomaticSequenceCollection", "BDotRCalc", "BDotTCalc", "BMagnitudeCalc", "BPlaneCollection", "BThetaCalc",
"BaseSelection", "BisectionControl", "BisectionControlCollection", "BisectionResult", "BisectionResultCollection",
"BlendedDensity", "BodyAxis", "BulirschStoerIntegrator", "BurnoutCBFCartesian", "BurnoutGeocentric", "BurnoutGeodetic",
"BurnoutLaunchAzAltitude", "BurnoutLaunchAzRadius", "BurnoutOptions", "BurnoutType", "BurnoutVelocity", "CR3BPFunction",
"CalculationGraphCollection", "CalculationObjectAngleSign", "CalculationObjectCentralBodyReference",
"CalculationObjectCollection", "CalculationObjectDirection", "CalculationObjectElement",
"CalculationObjectLinkEmbedControlCollection", "CalculationObjectLocationSource", "CalculationObjectOrbitPlaneSource",
"CalculationObjectReference", "CalculationObjectReferenceDirection", "CalculationObjectReferenceEllipse",
"CalculationObjectRelativePosition", "CalculationObjectSunPosition", "CentralBodyAttitude", "CentralBodyComponent",
"CentralBodyComponentAttitudeIAU1994", "CentralBodyComponentAttitudeRotationCoefficientsFile",
"CentralBodyComponentCollection", "CentralBodyComponentEphemerisAnalyticOrbit", "CentralBodyComponentEphemerisFile",
"CentralBodyComponentEphemerisJPLDesignExplorerOptimizer", "CentralBodyComponentEphemerisJPLSpice",
"CentralBodyComponentEphemerisPlanetary", "CentralBodyComponentGravityModel", "CentralBodyComponentShapeOblateSpheroid",
"CentralBodyComponentShapeSphere", "CentralBodyComponentShapeTriaxialEllipsoid", "CentralBodyEphemeris",
"CentralBodyGravityModel", "CentralBodyShape", "Cira72Function", "ClearEphemerisDirection", "CoeffRungeKuttaV8th9th",
"ComplexNumber", "ConstraintCollection", "ConstraintSign", "ControlAdvanced", "ControlEngineConstant",
"ControlEngineConstantAcceleration", "ControlEngineCustom", "ControlEngineIon", "ControlEngineModelPolynomial",
"ControlEngineThrottleTable", "ControlFollow", "ControlInitState", "ControlLaunch", "ControlManeuver",
"ControlOrbitStateValue", "ControlPowerInternal", "ControlPowerProcessed", "ControlPowerSolarArray",
"ControlRepeatingGroundTrackErr", "ControlStoppingCondition", "ControlThrusters", "ControlUpdate",
"ConvergenceCriteria", "Criteria", "Criterion", "CustomFunction", "CustomFunctionScriptEngine", "DTM2012", "DTM2020",
"DensityModelPlugin", "DerivativeCalculationMethod", "DesignCR3BPObject", "DesignCR3BPObjectCollection",
"DesignCR3BPSetup", "DesignER3BPObject", "DesignER3BPObjectCollection", "DesignER3BPSetup", "DifferenceOrder",
"DifferentialCorrectorControl", "DifferentialCorrectorControlCollection", "DifferentialCorrectorResult",
"DifferentialCorrectorResultCollection", "DifferentialCorrectorScalingMethod", "DisplaySystemGeocentric",
"DisplaySystemGeodetic", "DragModelPlugin", "DragModelType", "DrawPerturbation", "EOMFuncPluginFunction", "ER3BPFunc",
"EclipsingBodiesSource", "ElementBPlane", "ElementCartesian", "ElementDelaunay", "ElementEquinoctial",
"ElementGeodetic", "ElementKeplerian", "ElementMixedSpherical", "ElementSetType", "ElementSpherical",
"ElementSphericalRangeRate", "ElementTargetVectorIncomingAsymptote", "ElementTargetVectorOutgoingAsymptote",
"ElementType", "EngineConstant", "EngineConstantAcceleration", "EngineCustom", "EngineDefinition", "EngineIon",
"EngineModelFunction", "EngineModelIspCoefficients", "EngineModelPolynomial", "EngineModelThrustCoefficients",
"EnginePlugin", "EngineThrottleTable", "EphemerisSource", "ErrorControl", "Exponential", "FollowJoin",
"FollowSeparation", "FollowSpacecraftAndFuelTank", "Formulation", "FuelTank", "GaussJacksonIntegrator",
"GeneralRelativityFunction", "GeoMagneticFluxSource", "GeoMagneticFluxUpdateRate", "GeoStationaryDriftRateModel",
"GeoStationaryInclinationMagnitude", "GoldenSectionControl", "GoldenSectionControlCollection",
"GoldenSectionDesiredOperation", "GoldenSectionResult", "GoldenSectionResultCollection", "GraphOption",
"GravParamSource", "GravitationalParameterSource", "GravityCoefficientNormalizationType", "GravityCoefficientType",
"GravityFieldFunction", "GridSearchControl", "GridSearchControlCollection", "GridSearchDesiredOperation",
"GridSearchResult", "GridSearchResultCollection", "HPOPPluginFunction", "HarrisPriester", "IAttitudeControl",
"IAttitudeControlFinite", "IAttitudeControlImpulsive", "IAttitudeControlOptimalFinite", "IBurnout",
"ICentralBodyComponentAttitude", "ICentralBodyComponentEphemeris",
"ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides", "ICentralBodyComponentShape", "IDisplaySystem", "IElement",
"IMCSSegment", "IMCSSequence", "IManeuver", "INumericalIntegrator", "IPOPTControl", "IPOPTControlCollection",
"IPOPTGoal", "IPOPTResult", "IPOPTResultCollection", "IProfile", "IStoppingConditionComponent", "IdealOrbitRadius",
"ImpulsiveDeltaVRepresentation", "Jacchia1960", "Jacchia1970", "Jacchia1971", "JacchiaBowman2008", "JacchiaRoberts",
"LambertDirectionOfMotionType", "LambertOrbitalEnergyType", "LambertSolutionOptionType", "LambertTargetCoordinateType",
"Language", "LaunchDisplaySystem", "LightingCondition", "LightingStoppingCondition", "MCSBackwardSequence", "MCSDriver",
"MCSEnd", "MCSFollow", "MCSHold", "MCSInitialState", "MCSLaunch", "MCSManeuver", "MCSOptions", "MCSPropagate",
"MCSReturn", "MCSSegmentCollection", "MCSSegmentProperties", "MCSSequence", "MCSStop", "MCSTargetSequence", "MCSUpdate",
"MSIS1986", "MSISE1990", "ManeuverFinite", "ManeuverFinitePropagator", "ManeuverImpulsive", "ManeuverOptimalFinite",
"ManeuverOptimalFiniteBounds", "ManeuverOptimalFiniteFinalBoundaryConditions",
"ManeuverOptimalFiniteInitialBoundaryConditions", "ManeuverOptimalFinitePathBoundaryConditions",
"ManeuverOptimalFiniteSNOPTOptimizer", "ManeuverOptimalFiniteSteeringNodeCollection",
"ManeuverOptimalFiniteSteeringNodeElement", "ManeuverType", "MarsGRAM2000", "MarsGRAM2001", "MarsGRAM2005",
"MarsGRAM2010", "MarsGRAM37", "MarsGRAMDensityType", "NRLMSISE2000", "NumericalIntegrator",
"NumericalPropagatorWrapper", "NumericalPropagatorWrapperCR3BP", "OptimalFiniteDiscretizationStrategy",
"OptimalFiniteExportNodesFormat", "OptimalFiniteGuessMethod", "OptimalFiniteRunMode", "OptimalFiniteSNOPTObjective",
"OptimalFiniteSNOPTScaling", "OptimalFiniteScalingOptions", "OptimalFiniteSeedMethod", "OptimalFiniteWorkingVariables",
"PluginProperties", "PointMassFunction", "PowerInternal", "PowerProcessed", "PowerSolarArray", "PredictorCorrector",
"PressureMode", "Profile", "ProfileBisection", "ProfileChangeManeuverType", "ProfileChangePropagator",
"ProfileChangeReturnSegment", "ProfileChangeStopSegment", "ProfileChangeStoppingConditionState", "ProfileCollection",
"ProfileDifferentialCorrector", "ProfileGoldenSection", "ProfileGridSearch", "ProfileIPOPTOptimizer",
"ProfileInsertDirection", "ProfileLambertProfile", "ProfileLambertSearchProfile", "ProfileMode", "ProfileRunOnce",
"ProfileSNOPTOptimizer", "ProfileScriptingTool", "ProfileSearchPlugin", "ProfileSeedFiniteManeuver", "ProfilesFinish",
"PropagatorFunctionCollection", "PropulsionMethod", "RadiationPressureFunction", "ReferenceRadiusSource",
"ReturnControl", "RootFindingAlgorithm", "RotatingCoordinateSystem", "RunCode", "RungeKutta2nd3rd", "RungeKutta4th",
"RungeKutta4th5th", "RungeKutta4thAdapt", "RungeKuttaF7th8th", "RungeKuttaV8th9th", "SNOPTControl",
"SNOPTControlCollection", "SNOPTGoal", "SNOPTResult", "SNOPTResultCollection", "SRPAerospaceT20", "SRPAerospaceT30",
"SRPGSPM04aIIA", "SRPGSPM04aIIR", "SRPGSPM04aeIIA", "SRPGSPM04aeIIR", "SRPNPlate", "SRPReflectionPlugin",
"SRPSpherical", "SRPTabulatedAreaVector", "SRPVariableArea", "STMEigenNumber", "STMPerturbationVariables",
"ScriptingCalculationObject", "ScriptingCalculationObjectCollection", "ScriptingParameter",
"ScriptingParameterCollection", "ScriptingParameterEnumerationChoice", "ScriptingParameterEnumerationChoiceCollection",
"ScriptingParameterType", "ScriptingSegment", "ScriptingSegmentCollection", "ScriptingTool", "SearchPluginControl",
"SearchPluginControlCollection", "SearchPluginResult", "SearchPluginResultCollection", "SegmentDifferenceOrder",
"SegmentState", "SegmentType", "SequenceStateToPass", "ShadowModel", "SmartRunMode", "SolarForceMethod",
"SpacecraftParameters", "SquaredType", "State", "StateCalcAbsoluteValue", "StateCalcAltitudeOfApoapsis",
"StateCalcAltitudeOfPeriapsis", "StateCalcAngle", "StateCalcApparentSolarTime", "StateCalcArgumentOfLatitude",
"StateCalcArgumentOfPeriapsis", "StateCalcBetaAngle", "StateCalcC3Energy", "StateCalcCartSTMElem",
"StateCalcCartesianElem", "StateCalcCd", "StateCalcCloseApproachBearing", "StateCalcCloseApproachCosBearing",
"StateCalcCloseApproachMagnitude", "StateCalcCloseApproachTheta", "StateCalcCloseApproachX", "StateCalcCloseApproachY",
"StateCalcCosOfVerticalFlightPathAngle", "StateCalcCr", "StateCalcCurvilinearRelativeMotion", "StateCalcCustomFunction",
"StateCalcDamageFlux", "StateCalcDamageMassFlux", "StateCalcDec", "StateCalcDecRate", "StateCalcDeltaDec",
"StateCalcDeltaFromMaster", "StateCalcDeltaRA", "StateCalcDeltaV", "StateCalcDeltaVSquared", "StateCalcDensity",
"StateCalcDifference", "StateCalcDifferenceAcrossSegmentsOtherSatellite", "StateCalcDifferenceOtherSegment",
"StateCalcDotProduct", "StateCalcDragArea", "StateCalcDriftRateFactor", "StateCalcDuration",
"StateCalcEarthMeanLocalTimeOfAscendingNode", "StateCalcEarthMeanSolarTime", "StateCalcEccentricity",
"StateCalcEccentricityAnomaly", "StateCalcEccentricityX", "StateCalcEccentricityY", "StateCalcEnvironment",
"StateCalcEpoch", "StateCalcEquinoctialElem", "StateCalcFlightPathAngle", "StateCalcFuelMass", "StateCalcGeodeticElem",
"StateCalcGeodeticMeanRightAscension", "StateCalcGeodeticTrueLongitude",
"StateCalcGeodeticTrueLongitudeAtTimeOfPerigee", "StateCalcGravCoeff", "StateCalcGravitationalParameter",
"StateCalcHeightAboveTerrain", "StateCalcImpactFlux", "StateCalcImpactMassFlux", "StateCalcInAsympDec",
"StateCalcInAsympRA", "StateCalcInVelocityAzAtPeriapsis", "StateCalcInclination", "StateCalcInclinationX",
"StateCalcInclinationY", "StateCalcInertialDeltaVMagnitude", "StateCalcInertialDeltaVx", "StateCalcInertialDeltaVy",
"StateCalcInertialDeltaVz", "StateCalcJacobiConstant", "StateCalcJacobiOsculating", "StateCalcLocalApparentSolarLon",
"StateCalcLonDriftRate", "StateCalcLonOfAscNode", "StateCalcLonOfPeriapsis", "StateCalcMCSDeltaV",
"StateCalcMCSDeltaVSquared", "StateCalcMagneticFieldDipoleL", "StateCalcManeuverSpecificImpulse",
"StateCalcManeuverTotalMassFlowRate", "StateCalcMass", "StateCalcMaxValue", "StateCalcMeanAnomaly",
"StateCalcMeanEarthLon", "StateCalcMeanMotion", "StateCalcMeanRightAscension", "StateCalcMeanValue",
"StateCalcMedianValue", "StateCalcMinValue", "StateCalcNegative", "StateCalcNumRevs", "StateCalcOnePointAccess",
"StateCalcOrbitDelaunayG", "StateCalcOrbitDelaunayH", "StateCalcOrbitDelaunayL", "StateCalcOrbitPeriod",
"StateCalcOrbitSemilatusRectum", "StateCalcOrbitStateValue", "StateCalcOutAsympDec", "StateCalcOutAsympRA",
"StateCalcOutVelocityAzAtPeriapsis", "StateCalcPi", "StateCalcPositionDifferenceOtherSegment",
"StateCalcPositionVelocityDifferenceOtherSegment", "StateCalcPower", "StateCalcPressure", "StateCalcRA",
"StateCalcRAAN", "StateCalcRARate", "StateCalcRMagnitude", "StateCalcRadOfApoapsis", "StateCalcRadOfPeriapsis",
"StateCalcRadiationPressureArea", "StateCalcRadiationPressureCoefficient", "StateCalcRangeRate",
"StateCalcRectifiedLon", "StateCalcReferenceRadius", "StateCalcRelativeAtAOLMaster",
"StateCalcRelativeGroundTrackError", "StateCalcRelativeInclination", "StateCalcRelativeMotion",
"StateCalcRelativePositionDecAngle", "StateCalcRelativePositionInPlaneAngle", "StateCalcRepeatingGroundTrackErr",
"StateCalcSEETMagneticFieldLineSeparationAngle", "StateCalcSEETSAAFlux", "StateCalcSEETVehTemp", "StateCalcSRPArea",
"StateCalcSTMEigenval", "StateCalcSTMEigenvecElem", "StateCalcScalar", "StateCalcScript", "StateCalcSemimajorAxis",
"StateCalcSequenceDeltaV", "StateCalcSequenceDeltaVSquared", "StateCalcSignedEccentricity", "StateCalcSolarBetaAngle",
"StateCalcSolarInPlaneAngle", "StateCalcSpeedOfLight", "StateCalcStandardDeviation", "StateCalcTemperature",
"StateCalcTimePastAscNode", "StateCalcTimePastPeriapsis", "StateCalcTrueAnomaly", "StateCalcTrueLon",
"StateCalcTrueLongitude", "StateCalcTwoBodyDriftRate", "StateCalcUnitAngularMomentumX", "StateCalcUnitAngularMomentumY",
"StateCalcUnitAngularMomentumZ", "StateCalcUserValue", "StateCalcVMagnitude", "StateCalcValueAtSegment",
"StateCalcValueAtSegmentOtherSat", "StateCalcVectorDec", "StateCalcVectorGeometryToolAngle", "StateCalcVectorMagnitude",
"StateCalcVectorRA", "StateCalcVectorX", "StateCalcVectorY", "StateCalcVectorZ", "StateCalcVelocityAz",
"StateCalcVelocityDifferenceOtherSegment", "StateTransformationFunction", "StateType", "StoppingCondition",
"StoppingConditionCollection", "StoppingConditionElement", "StoppingConditionType", "SunPosition",
"TabVecInterpolationMethod", "TargetSequenceAction", "TargeterGraph", "TargeterGraphActiveControl",
"TargeterGraphActiveControlCollection", "TargeterGraphCollection", "TargeterGraphResult",
"TargeterGraphResultCollection", "ThirdBodyFunction", "ThirdBodyMode", "ThrottleTableOperationMode", "ThrustType",
"Thruster", "ThrusterDirection", "ThrusterSet", "ThrusterSetCollection", "TwoBodyFunction", "USStandardAtmosphere",
"UpdateAction", "UpdateParam", "UserVariable", "UserVariableCollection", "UserVariableDefinition",
"UserVariableDefinitionCollection", "UserVariableUpdate", "UserVariableUpdateCollection", "VenusGRAM2005",
"VenusGRAMDensityType", "YarkovskyFunc"]

from ctypes import POINTER
from enum import IntEnum
import typing

from ..internal import coclassutil as agcls, comutil as agcom, marshall as agmarshall
from ..internal.apiutil import (
    EnumeratorProxy,
    InterfaceProxy,
    OutArg,
    SupportsDeleteCallback,
    get_interface_property,
    initialize_from_source_object,
    set_class_attribute,
    set_interface_attribute,
)
from ..internal.comutil import IDispatch, IUnknown
from ..stkobjects import (
    AberrationType,
    ComponentLinkEmbedControlReferenceType,
    ICloneable,
    IComponentInfo,
    IComponentLinkEmbedControl,
    IPropagator,
    IvClockHost,
    IvTimeSense,
    SolidTide,
)
from ..stkutil import IDirection, IOrientation, IRuntimeTypeInfoProvider, RuntimeTypeInfo
from ..utilities import colors as agcolor
from ..utilities.exceptions import STKRuntimeError


def _raise_uninitialized_error(*args):
    raise STKRuntimeError("Valid STK object model classes are returned from STK methods and should not be created independently.")

class GraphOption(IntEnum):
    """Mode that the mcs will run in."""

    NO_GRAPH = 0
    """Don't graph."""
    GRAPH_DIFFERENCE = 1
    """Graph the difference."""
    GRAPH_VALUE = 2
    """Graph the value."""

GraphOption.NO_GRAPH.__doc__ = "Don't graph."
GraphOption.GRAPH_DIFFERENCE.__doc__ = "Graph the difference."
GraphOption.GRAPH_VALUE.__doc__ = "Graph the value."

agcls.AgTypeNameMap["GraphOption"] = GraphOption

class SmartRunMode(IntEnum):
    """Mode that the mcs will run in."""

    ENTIRE_MCS = 0
    """Run Entire Mission Control Sequence."""
    ONLY_CHANGED = 1
    """Run Only Changed Segments."""

SmartRunMode.ENTIRE_MCS.__doc__ = "Run Entire Mission Control Sequence."
SmartRunMode.ONLY_CHANGED.__doc__ = "Run Only Changed Segments."

agcls.AgTypeNameMap["SmartRunMode"] = SmartRunMode

class Formulation(IntEnum):
    """Equinoctial Formulation."""

    POSIGRADE = 0
    """Posigrade."""
    RETROGRADE = 1
    """Retrograde."""

Formulation.POSIGRADE.__doc__ = "Posigrade."
Formulation.RETROGRADE.__doc__ = "Retrograde."

agcls.AgTypeNameMap["Formulation"] = Formulation

class LightingCondition(IntEnum):
    """The criteria of a Lighting stopping condition."""

    CRITERION_ENTER_DIRECT_SUN = 0
    """The Enter Direct Sun criterion."""
    CRITERION_EXIT_DIRECT_SUN = 1
    """The Exit Direct Sun criterion."""
    CRITERION_ENTER_UMBRA = 2
    """The Enter Umbra criterion."""
    CRITERION_EXIT_UMBRA = 3
    """The Exit Umbra criterion."""

LightingCondition.CRITERION_ENTER_DIRECT_SUN.__doc__ = "The Enter Direct Sun criterion."
LightingCondition.CRITERION_EXIT_DIRECT_SUN.__doc__ = "The Exit Direct Sun criterion."
LightingCondition.CRITERION_ENTER_UMBRA.__doc__ = "The Enter Umbra criterion."
LightingCondition.CRITERION_EXIT_UMBRA.__doc__ = "The Exit Umbra criterion."

agcls.AgTypeNameMap["LightingCondition"] = LightingCondition

class Profile(IntEnum):
    """Type of profile."""

    SEARCH_PLUGIN = 0
    """Plugin search profile."""
    DIFFERENTIAL_CORRECTOR = 2
    """Differential corrector profile."""
    CHANGE_MANEUVER_TYPE = 3
    """Change maneuver type profile."""
    SCRIPTING_TOOL = 4
    """Scripting tool profile."""
    CHANGE_RETURN_SEGMENT = 5
    """Change return segment profile."""
    CHANGE_PROPAGATOR = 6
    """Change propagator profile."""
    CHANGE_STOP_SEGMENT = 7
    """Change stop segment profile."""
    CHANGE_STOPPING_CONDITION_STATE = 8
    """Change stopping condition state profile."""
    SEED_FINITE_MANEUVER = 9
    """Change seed finite maneuver profile."""
    RUN_ONCE = 10
    """Run once profile."""
    SNOPT_OPTIMIZER = 11
    """SNOPT Optimizer profile."""
    IPOPT_OPTIMIZER = 12
    """IPOPT Optimizer profile."""
    LAMBERT_PROFILE = 13
    """Lambert profile."""
    LAMBERT_SEARCH_PROFILE = 14
    """Lambert Search profile."""
    GOLDEN_SECTION = 15
    """Golden Section profile."""
    GRID_SEARCH = 16
    """grid Search profile."""
    BISECTION = 17
    """Single Parameter Bisection profile."""

Profile.SEARCH_PLUGIN.__doc__ = "Plugin search profile."
Profile.DIFFERENTIAL_CORRECTOR.__doc__ = "Differential corrector profile."
Profile.CHANGE_MANEUVER_TYPE.__doc__ = "Change maneuver type profile."
Profile.SCRIPTING_TOOL.__doc__ = "Scripting tool profile."
Profile.CHANGE_RETURN_SEGMENT.__doc__ = "Change return segment profile."
Profile.CHANGE_PROPAGATOR.__doc__ = "Change propagator profile."
Profile.CHANGE_STOP_SEGMENT.__doc__ = "Change stop segment profile."
Profile.CHANGE_STOPPING_CONDITION_STATE.__doc__ = "Change stopping condition state profile."
Profile.SEED_FINITE_MANEUVER.__doc__ = "Change seed finite maneuver profile."
Profile.RUN_ONCE.__doc__ = "Run once profile."
Profile.SNOPT_OPTIMIZER.__doc__ = "SNOPT Optimizer profile."
Profile.IPOPT_OPTIMIZER.__doc__ = "IPOPT Optimizer profile."
Profile.LAMBERT_PROFILE.__doc__ = "Lambert profile."
Profile.LAMBERT_SEARCH_PROFILE.__doc__ = "Lambert Search profile."
Profile.GOLDEN_SECTION.__doc__ = "Golden Section profile."
Profile.GRID_SEARCH.__doc__ = "grid Search profile."
Profile.BISECTION.__doc__ = "Single Parameter Bisection profile."

agcls.AgTypeNameMap["Profile"] = Profile

class AccessCriterion(IntEnum):
    """The criteria of an Access stopping condition."""

    GAIN = 0
    """The Gain Access criterion."""
    LOSE = 1
    """The Lose Access criterion."""
    EITHER = 2
    """The Either criterion."""

AccessCriterion.GAIN.__doc__ = "The Gain Access criterion."
AccessCriterion.LOSE.__doc__ = "The Lose Access criterion."
AccessCriterion.EITHER.__doc__ = "The Either criterion."

agcls.AgTypeNameMap["AccessCriterion"] = AccessCriterion

class EclipsingBodiesSource(IntEnum):
    """The source types of the eclipsing bodies list."""

    PROPAGATOR_CENTRAL_BODY = 0
    """The eclipsing bodies list of the propagator's central body."""
    USER_DEFINED = 1
    """A user-defined eclipsing bodies list related to the propagator's central body."""
    VEHICLE_CENTRAL_BODY = 2
    """The eclipsing bodies list of the vehicle's central body."""
    VEHICLE_USER_DEFINED = 3
    """A list of eclipsing bodies from the vehicle's Basic Properties->Eclipse Bodies list."""

EclipsingBodiesSource.PROPAGATOR_CENTRAL_BODY.__doc__ = "The eclipsing bodies list of the propagator's central body."
EclipsingBodiesSource.USER_DEFINED.__doc__ = "A user-defined eclipsing bodies list related to the propagator's central body."
EclipsingBodiesSource.VEHICLE_CENTRAL_BODY.__doc__ = "The eclipsing bodies list of the vehicle's central body."
EclipsingBodiesSource.VEHICLE_USER_DEFINED.__doc__ = "A list of eclipsing bodies from the vehicle's Basic Properties->Eclipse Bodies list."

agcls.AgTypeNameMap["EclipsingBodiesSource"] = EclipsingBodiesSource

class Criterion(IntEnum):
    """The stopping condition criterion types."""

    CROSS_DECREASING = 0
    """The Cross Decreasing criterion - the stopping condition is satisfied when the parameter reaches a value equal to the trip value while decreasing."""
    CROSS_EITHER = 1
    """The Cross Either criterion - the stopping condition is satisfied when either of the above situations occurs."""
    CROSS_INCREASING = 2
    """The Cross Increasing criterion - the stopping condition is satisfied when the parameter reaches a value equal to the trip value while increasing."""

Criterion.CROSS_DECREASING.__doc__ = "The Cross Decreasing criterion - the stopping condition is satisfied when the parameter reaches a value equal to the trip value while decreasing."
Criterion.CROSS_EITHER.__doc__ = "The Cross Either criterion - the stopping condition is satisfied when either of the above situations occurs."
Criterion.CROSS_INCREASING.__doc__ = "The Cross Increasing criterion - the stopping condition is satisfied when the parameter reaches a value equal to the trip value while increasing."

agcls.AgTypeNameMap["Criterion"] = Criterion

class CalculationObjectReference(IntEnum):
    """The calculation object Reference Selection types."""

    BASIC = 0
    """The Use Basic Reference type - uses the current satellite as the reference vehicle."""
    SPECIFIED = 1
    """The UserSpecifiedReference type - uses a user specified vehicle object as the reference vehicle."""

CalculationObjectReference.BASIC.__doc__ = "The Use Basic Reference type - uses the current satellite as the reference vehicle."
CalculationObjectReference.SPECIFIED.__doc__ = "The UserSpecifiedReference type - uses a user specified vehicle object as the reference vehicle."

agcls.AgTypeNameMap["CalculationObjectReference"] = CalculationObjectReference

class CalculationObjectCentralBodyReference(IntEnum):
    """The calculation object Central Body Reference Selection types."""

    SPECIFIED = 0
    """The Use Basic Reference type - uses the current satellite as the reference vehicle."""
    PARENT = 1
    """The UserSpecifiedReference type - uses a user specified vehicle object as the reference vehicle."""

CalculationObjectCentralBodyReference.SPECIFIED.__doc__ = "The Use Basic Reference type - uses the current satellite as the reference vehicle."
CalculationObjectCentralBodyReference.PARENT.__doc__ = "The UserSpecifiedReference type - uses a user specified vehicle object as the reference vehicle."

agcls.AgTypeNameMap["CalculationObjectCentralBodyReference"] = CalculationObjectCentralBodyReference

class CalculationObjectElement(IntEnum):
    """The calculation object Element Types."""

    BROUWER_LYDDANE_MEAN_LONG = 0
    """Brouwer-Lyddane mean elements considering both the short and long period terms (i.e. resulting from averaging over the rotation of periapse). The perturbation terms are the J2, J3, J4 and J5 oblateness terms and it considers the term involving J2^2."""
    BROUWER_LYDDANE_MEAN_SHORT = 1
    """Brouwer-Lyddane Mean Short - Brouwer-Lyddane mean elements considering only the short period terms (i.e. those involving averaging over the period of the orbit) where the only perturbation force is the oblateness arising from the J2 gravity term."""
    KOZAI_IZSAK_MEAN = 2
    """Kozai-Izsak Mean - Kozai-Izsak mean elements for which only the short period terms (i.e. those involving averaging over the period of the orbit) are considered. The only perturbation force considered is the oblateness arising from the J2 gravity term."""
    OSCULATING = 3
    """Osculating."""

CalculationObjectElement.BROUWER_LYDDANE_MEAN_LONG.__doc__ = "Brouwer-Lyddane mean elements considering both the short and long period terms (i.e. resulting from averaging over the rotation of periapse). The perturbation terms are the J2, J3, J4 and J5 oblateness terms and it considers the term involving J2^2."
CalculationObjectElement.BROUWER_LYDDANE_MEAN_SHORT.__doc__ = "Brouwer-Lyddane Mean Short - Brouwer-Lyddane mean elements considering only the short period terms (i.e. those involving averaging over the period of the orbit) where the only perturbation force is the oblateness arising from the J2 gravity term."
CalculationObjectElement.KOZAI_IZSAK_MEAN.__doc__ = "Kozai-Izsak Mean - Kozai-Izsak mean elements for which only the short period terms (i.e. those involving averaging over the period of the orbit) are considered. The only perturbation force considered is the oblateness arising from the J2 gravity term."
CalculationObjectElement.OSCULATING.__doc__ = "Osculating."

agcls.AgTypeNameMap["CalculationObjectElement"] = CalculationObjectElement

class ProfileMode(IntEnum):
    """The Target Sequence profile modes."""

    ITERATE = 0
    """Iterate - the Target Sequence will run the profile as it is configured in an attempt to attain the desired solution."""
    NOT_ACTIVE = 1
    """Not Active - the Target Sequence will ignore the profile when running."""
    RUN_ONCE = 2
    """Run Once - the Target Sequence will run the profile once according to its current configuration."""
    ACTIVE = 3
    """Active - the Target Sequence will apply the change that the profile passes when running."""

ProfileMode.ITERATE.__doc__ = "Iterate - the Target Sequence will run the profile as it is configured in an attempt to attain the desired solution."
ProfileMode.NOT_ACTIVE.__doc__ = "Not Active - the Target Sequence will ignore the profile when running."
ProfileMode.RUN_ONCE.__doc__ = "Run Once - the Target Sequence will run the profile once according to its current configuration."
ProfileMode.ACTIVE.__doc__ = "Active - the Target Sequence will apply the change that the profile passes when running."

agcls.AgTypeNameMap["ProfileMode"] = ProfileMode

class ControlStoppingCondition(IntEnum):
    """The stopping condition control types."""

    TRIP_VALUE = 0
    """Trip - the value at which the stopping condition will be satisfied."""

ControlStoppingCondition.TRIP_VALUE.__doc__ = "Trip - the value at which the stopping condition will be satisfied."

agcls.AgTypeNameMap["ControlStoppingCondition"] = ControlStoppingCondition

class StateType(IntEnum):
    """The Stop segment state types."""

    ENABLED = 0
    """Enabled - the segment stops the run of the MCS."""
    DISABLED = 1
    """Disabled - the MCS ignores this segment and continues to run."""

StateType.ENABLED.__doc__ = "Enabled - the segment stops the run of the MCS."
StateType.DISABLED.__doc__ = "Disabled - the MCS ignores this segment and continues to run."

agcls.AgTypeNameMap["StateType"] = StateType

class ReturnControl(IntEnum):
    """The Return segment control types."""

    ENABLE = 0
    """Enable - returns control of the MCS run to the parent segment."""
    DISABLE = 1
    """Disable - the MCS ignores this segment and continues to run."""
    ENABLE_EXCEPT_PROFILES_BYPASS = 2
    """Enable (except Profiles bypass)- functions as enabled except when run from a Target Sequence profile (e.g., a differential corrector), which will ignore it."""

ReturnControl.ENABLE.__doc__ = "Enable - returns control of the MCS run to the parent segment."
ReturnControl.DISABLE.__doc__ = "Disable - the MCS ignores this segment and continues to run."
ReturnControl.ENABLE_EXCEPT_PROFILES_BYPASS.__doc__ = "Enable (except Profiles bypass)- functions as enabled except when run from a Target Sequence profile (e.g., a differential corrector), which will ignore it."

agcls.AgTypeNameMap["ReturnControl"] = ReturnControl

class DrawPerturbation(IntEnum):
    """The Draw Perturbation types for a Differential Corrector profile."""

    SEGMENT_COLOR = 0
    """Segment Color - perturbations will be displayed in the trajectory color defined for the individual segments within the target sequence."""
    DONT_DRAW = 1
    """Don't Draw - perturbations will not be drawn, which may decrease the run time of the target sequence."""
    TARGETER_COLOR = 2
    """Targeter Color - perturbations will be displayed in the trajectory color defined for the target sequence."""

DrawPerturbation.SEGMENT_COLOR.__doc__ = "Segment Color - perturbations will be displayed in the trajectory color defined for the individual segments within the target sequence."
DrawPerturbation.DONT_DRAW.__doc__ = "Don't Draw - perturbations will not be drawn, which may decrease the run time of the target sequence."
DrawPerturbation.TARGETER_COLOR.__doc__ = "Targeter Color - perturbations will be displayed in the trajectory color defined for the target sequence."

agcls.AgTypeNameMap["DrawPerturbation"] = DrawPerturbation

class DerivativeCalculationMethod(IntEnum):
    """The Derivative Calculation method types for a Differential Corrector profile."""

    FORWARD = 0
    """Forward Difference - ((f(x + delta) - f(x))/ delta)."""
    CENTRAL = 1
    """Central Difference - ((f(x + delta) - f(x - delta)) / 2delta)."""
    SIGNED = 2
    """Signed Difference - if x is positive, use the forward difference; if x is negative, use the backward difference."""

DerivativeCalculationMethod.FORWARD.__doc__ = "Forward Difference - ((f(x + delta) - f(x))/ delta)."
DerivativeCalculationMethod.CENTRAL.__doc__ = "Central Difference - ((f(x + delta) - f(x - delta)) / 2delta)."
DerivativeCalculationMethod.SIGNED.__doc__ = "Signed Difference - if x is positive, use the forward difference; if x is negative, use the backward difference."

agcls.AgTypeNameMap["DerivativeCalculationMethod"] = DerivativeCalculationMethod

class ConvergenceCriteria(IntEnum):
    """The Convergence Criteria types for a Differential Corrector profile."""

    EQUALITY_CONSTRAINT_WITHIN_TOLERANCE = 0
    """Equality Constraints Satisfied - the differences between the achieved and desired equality constraint values must be within the specified tolerances for convergence."""
    CONVERVENCE_CRITERIA_EITHER_EQUALITY_CONSTRAINTS_OR_CONTROL_PARAMS = 1
    """Equality Constraints Satisfied or Parameter Variations within Tolerance - the differences between the achieved and desired EC values must be within tolerances, or the last updates to the control parameters must be within tolerances for convergence."""

ConvergenceCriteria.EQUALITY_CONSTRAINT_WITHIN_TOLERANCE.__doc__ = "Equality Constraints Satisfied - the differences between the achieved and desired equality constraint values must be within the specified tolerances for convergence."
ConvergenceCriteria.CONVERVENCE_CRITERIA_EITHER_EQUALITY_CONSTRAINTS_OR_CONTROL_PARAMS.__doc__ = "Equality Constraints Satisfied or Parameter Variations within Tolerance - the differences between the achieved and desired EC values must be within tolerances, or the last updates to the control parameters must be within tolerances for convergence."

agcls.AgTypeNameMap["ConvergenceCriteria"] = ConvergenceCriteria

class DifferentialCorrectorScalingMethod(IntEnum):
    """The Scaling Method types for a Differential Corrector profile."""

    INITIAL_VALUE = 0
    """By initial value."""
    ONE_NO_SCALING = 1
    """By one (no scaling)."""
    SPECIFIED_VALUE = 2
    """By specified value."""
    TOLERANCE = 3
    """By tolerance."""

DifferentialCorrectorScalingMethod.INITIAL_VALUE.__doc__ = "By initial value."
DifferentialCorrectorScalingMethod.ONE_NO_SCALING.__doc__ = "By one (no scaling)."
DifferentialCorrectorScalingMethod.SPECIFIED_VALUE.__doc__ = "By specified value."
DifferentialCorrectorScalingMethod.TOLERANCE.__doc__ = "By tolerance."

agcls.AgTypeNameMap["DifferentialCorrectorScalingMethod"] = DifferentialCorrectorScalingMethod

class ControlUpdate(IntEnum):
    """Update segment properties that can be selected as control parameters for a Target Sequence."""

    CD = 100
    """Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."""
    CR = 101
    """Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    DRAG_AREA = 102
    """Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."""
    DRY_MASS = 103
    """Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."""
    FUEL_DENSITY = 104
    """Fuel Density - the density of the fuel tank. Enter a value in the selected mass unit per the selected distance unit cubed (e.g. kg/m^3)."""
    FUEL_MASS = 105
    """Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."""
    RADIATION_PRESSURE_AREA = 106
    """The cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Enter a value in the selected distance unit squared."""
    RADIATION_PRESSURE_COEFFICIENT = 107
    """Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    SRP_AREA = 108
    """Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Enter a value in the selected distance unit squared."""
    TANK_PRESSURE = 109
    """Tank Pressure - the fuel tank pressure. Enter a value in the selected pressure unit (e.g. Pa)."""
    TANK_TEMPERATURE = 110
    """Tank Temperature - the temperature of the fuel tank. Enter a value in the selected temperature unit."""

ControlUpdate.CD.__doc__ = "Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."
ControlUpdate.CR.__doc__ = "Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlUpdate.DRAG_AREA.__doc__ = "Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."
ControlUpdate.DRY_MASS.__doc__ = "Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlUpdate.FUEL_DENSITY.__doc__ = "Fuel Density - the density of the fuel tank. Enter a value in the selected mass unit per the selected distance unit cubed (e.g. kg/m^3)."
ControlUpdate.FUEL_MASS.__doc__ = "Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlUpdate.RADIATION_PRESSURE_AREA.__doc__ = "The cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Enter a value in the selected distance unit squared."
ControlUpdate.RADIATION_PRESSURE_COEFFICIENT.__doc__ = "Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlUpdate.SRP_AREA.__doc__ = "Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Enter a value in the selected distance unit squared."
ControlUpdate.TANK_PRESSURE.__doc__ = "Tank Pressure - the fuel tank pressure. Enter a value in the selected pressure unit (e.g. Pa)."
ControlUpdate.TANK_TEMPERATURE.__doc__ = "Tank Temperature - the temperature of the fuel tank. Enter a value in the selected temperature unit."

agcls.AgTypeNameMap["ControlUpdate"] = ControlUpdate

class ControlFollow(IntEnum):
    """Follow segment properties that can be selected as control parameters for a Target Sequence."""

    FUEL_MASS = 200
    """Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."""
    CD = 201
    """Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."""
    CR = 202
    """Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    DRAG_AREA = 203
    """Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."""
    DRY_MASS = 204
    """Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."""
    FUEL_DENSITY = 205
    """Fuel Density - the density of the fuel tank. Enter a value in the selected mass unit per the selected distance unit cubed (e.g. kg/m^3)."""
    K1 = 206
    """GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."""
    K2 = 207
    """GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (Y bias) value."""
    RADIATION_PRESSURE_AREA = 208
    """The cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Enter a value in the selected distance unit squared."""
    CK = 209
    """Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    SRP_AREA = 210
    """Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Enter a value in the selected distance unit squared."""
    TANK_PRESSURE = 211
    """Tank Pressure - the fuel tank pressure. Enter a value in the selected pressure unit (e.g. Pa)."""
    TANK_TEMPERATURE = 212
    """Tank Temperature - the temperature of the fuel tank. Enter a value in the selected temperature unit."""
    MAX_FUEL_MASS = 213
    """Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences. Enter a value in the selected mass unit (e.g. kg)."""
    TANK_VOLUME = 214
    """Tank Volume - the volume of the fuel tank. Enter a value in the selected distance unit cubed (e.g. m^3). The minimum value is 1e-019 m^3."""
    X_OFFSET = 215
    """X Offset - the distance that the spacecraft will be offset from the leader's body frame along the X axis."""
    Y_OFFSET = 216
    """Y Offset - the distance that the spacecraft will be offset from the leader's body frame along the Y axis."""
    Z_OFFSET = 217
    """Z Offset - the distance that the spacecraft will be offset from the leader's body frame along the Z axis."""

ControlFollow.FUEL_MASS.__doc__ = "Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlFollow.CD.__doc__ = "Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."
ControlFollow.CR.__doc__ = "Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlFollow.DRAG_AREA.__doc__ = "Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."
ControlFollow.DRY_MASS.__doc__ = "Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlFollow.FUEL_DENSITY.__doc__ = "Fuel Density - the density of the fuel tank. Enter a value in the selected mass unit per the selected distance unit cubed (e.g. kg/m^3)."
ControlFollow.K1.__doc__ = "GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."
ControlFollow.K2.__doc__ = "GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (Y bias) value."
ControlFollow.RADIATION_PRESSURE_AREA.__doc__ = "The cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Enter a value in the selected distance unit squared."
ControlFollow.CK.__doc__ = "Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlFollow.SRP_AREA.__doc__ = "Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Enter a value in the selected distance unit squared."
ControlFollow.TANK_PRESSURE.__doc__ = "Tank Pressure - the fuel tank pressure. Enter a value in the selected pressure unit (e.g. Pa)."
ControlFollow.TANK_TEMPERATURE.__doc__ = "Tank Temperature - the temperature of the fuel tank. Enter a value in the selected temperature unit."
ControlFollow.MAX_FUEL_MASS.__doc__ = "Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences. Enter a value in the selected mass unit (e.g. kg)."
ControlFollow.TANK_VOLUME.__doc__ = "Tank Volume - the volume of the fuel tank. Enter a value in the selected distance unit cubed (e.g. m^3). The minimum value is 1e-019 m^3."
ControlFollow.X_OFFSET.__doc__ = "X Offset - the distance that the spacecraft will be offset from the leader's body frame along the X axis."
ControlFollow.Y_OFFSET.__doc__ = "Y Offset - the distance that the spacecraft will be offset from the leader's body frame along the Y axis."
ControlFollow.Z_OFFSET.__doc__ = "Z Offset - the distance that the spacecraft will be offset from the leader's body frame along the Z axis."

agcls.AgTypeNameMap["ControlFollow"] = ControlFollow

class ControlInitState(IntEnum):
    """Initial State segment properties that can be selected as control parameters for a Target Sequence."""

    FUEL_MASS = 300
    """Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."""
    CARTESIAN_VX = 301
    """Vx Component - the X component of the spacecraft velocity vector."""
    CARTESIAN_VY = 302
    """Vy Component - the Y component of the spacecraft velocity vector."""
    CARTESIAN_VZ = 303
    """Vz Component - the Z component of the spacecraft velocity vector."""
    CARTESIAN_X = 304
    """X Component - the X component of the spacecraft position vector."""
    CARTESIAN_Y = 305
    """Y Component - the Y component of the spacecraft position vector."""
    CARTESIAN_Z = 306
    """Z Component - the Z component of the spacecraft position vector."""
    CD = 307
    """Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."""
    CR = 308
    """Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    DRAG_AREA = 309
    """Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."""
    DRY_MASS = 310
    """Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."""
    EPOCH = 311
    """Epoch - the orbit epoch."""
    FUEL_DENSITY = 312
    """Fuel Density - the density of the fuel tank."""
    K1 = 313
    """GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."""
    K2 = 314
    """GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (Y bias) value."""
    KEPLERIAN_ECCENTRICITY = 315
    """Eccentricity - the ratio of the distance between the foci to the major axis of the orbital ellipse. Dimensionless."""
    KEPLERIAN_INCLINATION = 316
    """Inclination - the angle from the +Z axis of the coordinate system to the angular momentum vector of the spacecraft's orbit."""
    KEPLERIAN_RAAN = 317
    """Right Ascension of Ascending Node - the angle between the X direction of the coordinate system and the point where the orbit crosses the X-Y plane in the +Z direction."""
    KEPLERIAN_SEMIMAJOR_AXIS = 318
    """Semimajor Axis - half the length of the major (longest) axis of the orbital ellipse."""
    KEPLERIAN_TRUE_ANOMALY = 319
    """True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."""
    KEPLERIAN_W = 320
    """Argument of Periapsis - the angle measured in the direction of spacecraft motion, in the orbit plane, from the ascending node to the periapsis of the orbit."""
    RADIATION_PRESSURE_AREA = 327
    """Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."""
    CK = 328
    """Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    SPHERICAL_AZIMUTH = 329
    """Velocity Azimuth - the angle in the spacecraft local horizontal plane between the projection of the velocity vector onto that plane and the local +Z direction measured as positive in the clockwise direction from north."""
    SPHERICAL_DECLINATION = 330
    """Declination - the angle from the X-Y plane of the coordinate system to the spacecraft position vector."""
    SPHERICAL_HORIZONTAL_FLIGHT_PATH_ANGLE = 331
    """Horizontal Flight Path Angle - the complement of the angle between the spacecraft velocity vector and the radius vector (90 deg minus the vertical flight path angle)."""
    SPHERICAL_RIGHT_ASCENSION = 332
    """Right Ascension - angle measured in the inertial equatorial plane from the inertial X axis in a right-handed sense about the inertial Z axis to the spacecraft position vector."""
    SPHERICAL_RADIUS_MAGNITUDE = 333
    """Radius Magnitude - the magnitude of the spacecraft position vector."""
    SPHERICAL_VELOCITY_MAGNITUDE = 334
    """Velocity Magnitude - the magnitude of the spacecraft velocity vector."""
    SRP_AREA = 335
    """Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."""
    TANK_PRESSURE = 336
    """Tank Pressure - the fuel tank pressure."""
    TANK_TEMPERATURE = 337
    """Tank Temperature - the temperature of the fuel tank."""
    TARGET_VECTOR_INCOMING_ASYMPTOTE_DECLINATION = 338
    """Declination of Incoming Asymptote - the declination of the incoming asymptote in the selected coordinate system."""
    TARGET_VECTOR_INCOMING_ASYMPTOTE_RIGHT_ASCENSION = 339
    """Right Ascension of Incoming Asymptote - the right ascension of the hyperbolic incoming asymptote in the selected coordinate system."""
    TARGET_VECTOR_INCOMING_VELOCITY_AZIMUTH_AT_PERIAPSIS = 340
    """Velocity Azimuth at Periapsis - the inertial flight path azimuth of the trajectory measured at periapsis."""
    TARGET_VECTOR_INCOMING_C3 = 341
    """C3 Energy - the energy of the orbit, computed as - mu / a, where mu is the gravity constant of the central body and a is the semimajor axis."""
    TARGET_VECTOR_INCOMING_RADIUS_OF_PERIAPSIS = 342
    """Radius of Periapsis - distance from the center of mass of the central body to the periapsis of the hyperbolic orbit."""
    TARGET_VECTOR_INCOMING_TRUE_ANOMALY = 343
    """True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."""
    TARGET_VECTOR_OUTGOING_ASYMPTOTE_DECLINATION = 344
    """Declination of Outgoing Asymptote - the declination of the outgoing asymptote in the selected coordinate system."""
    TARGET_VECTOR_OUTGOING_ASYMPTOTE_RIGHT_ASCENSION = 345
    """Right Ascension of Outgoing Asymptote - the right ascension of the hyperbolic outgoing asymptote in the selected coordinate system."""
    TARGET_VECTOR_OUTGOING_VELOCITY_AZIMUTH_AT_PERIAPSIS = 346
    """Velocity Azimuth at Periapsis - the inertial flight path azimuth of the trajectory measured at periapsis."""
    TARGET_VECTOR_OUTGOING_C3 = 347
    """C3 Energy - the energy of the orbit, computed as - mu / a, where mu is the gravity constant of the central body and a is the semimajor axis."""
    TARGET_VECTOR_OUTGOING_RADIUS_OF_PERIAPSIS = 348
    """Radius of Periapsis - distance from the center of mass of the central body to the periapsis of the hyperbolic orbit."""
    TARGET_VECTOR_OUTGOING_TRUE_ANOMALY = 349
    """True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."""
    MAX_FUEL_MASS = 350
    """Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences."""
    TANK_VOLUME = 351
    """Tank Volume - the volume of the fuel tank."""
    DELAUNAY_G = 352
    """G - Magnitude of orbital angular momentum, (G: sqrt(GM * p))."""
    DELAUNAY_H = 353
    """H - Z component of orbital angular momentum, (H: G cos(inc))."""
    DELAUNAY_INCLINATION = 354
    """Inclination - The angle between the angular momentum vector (perpendicular to the plane of the orbit) and the inertial Z axis."""
    DELAUNAY_L = 355
    """L - Related to two-body orbital energy, (L: sqrt(GM * a))."""
    DELAUNAY_MEAN_ANOMALY = 356
    """Mean Anomaly - The angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate."""
    DELAUNAY_RAAN = 357
    """Right Ascension of Ascending Node - The angle from the inertial X axis to the ascending node measured in a right-handed sense about the inertial Z axis in the equatorial plane."""
    DELAUNAY_SEMILATUS_RECTUM = 358
    """Semi-latus Rectum - Distance from focus to orbit at true anomaly of 90 degrees."""
    DELAUNAY_SEMIMAJOR_AXIS = 359
    """Semimajor Axis - Half the length of the major (longest) axis of the orbital ellipse."""
    DELAUNAY_W = 360
    """Argument of Periapsis - The angle from the ascending node to the eccentricity vector measured in the direction of the satellite's motion and in the orbit plane."""
    EQUINOCTIAL_H = 361
    """H - With K, describe the shape and position of periapsis of the orbit, (H: ecc * sin(RAAN + w))."""
    EQUINOCTIAL_K = 362
    """K - With H, describe the shape and position of periapsis of the orbit, (K: ecc * cos(RAAN + w))."""
    EQUINOCTIAL_MEAN_LONGITUDE = 363
    """Mean Longitude - (RAAN + w + M)."""
    EQUINOCTIAL_MEAN_MOTION = 364
    """Mean Motion - The number of orbits per day (86400 sec/period), based on assumed two-body motion."""
    EQUINOCTIAL_P = 365
    """P - With Q, describes the orientation of the orbit plane, (P: tan(inc/2) * sin(RAAN))."""
    EQUINOCTIAL_Q = 366
    """Q - With P, describes the orientation of the orbit plane, (Q: tan(inc/2) * cos(RAAN))."""
    EQUINOCTIAL_SEMIMAJOR_AXIS = 367
    """Semimajor Axis - Half the length of the major (longest) axis of the orbital ellipse."""
    MIXED_SPHERICAL_ALTITUDE = 368
    """Altitude - The object's position above or below the reference ellipsoid. Altitude is measured along a normal to the surface of the reference ellipsoid."""
    MIXED_SPHERICAL_AZIMUTH = 369
    """Azimuth - The angle in the satellite local horizontal plane between the projection of the inertial velocity vector onto this plane and the local north direction measured as positive in the clockwise direction."""
    MIXED_SPHERICAL_HORIZONTAL_FLIGHT_PATH_ANGLE = 370
    """Horizontal Flight Path Angle - The complement of the angle between the inertial velocity vector and the radius vector."""
    MIXED_SPHERICAL_LATITUDE = 371
    """Latitude - The geodetic latitude of a point is the angle between the normal to the reference ellipsoid that passes through the satellite position and the equatorial plane."""
    MIXED_SPHERICAL_LONGITUDE = 372
    """Longitude."""
    MIXED_SPHERICAL_VERTICAL_FLIGHT_PATH_ANGLE = 373
    """Vertical Flight Path Angle -  The angle between the inertial velocity vector and the radius vector."""
    MIXED_SPHERICAL_V_MAGNITUDE = 374
    """Velocity Magnitude - The magnitude of the inertial velocity vector."""
    SPHERICAL_VERTICAL_FLIGHT_PATH_ANGLE = 375
    """Vertical Flight Path Angle -  The angle between the inertial velocity vector and the radius vector."""
    KEPLERIAN_APOAPSIS_ALTITUDE_SHAPE = 376
    """Apoapsis Altitude - Shape Parameter - Distance from the surface of the central body to the point of maximum radius in the orbit."""
    KEPLERIAN_APOAPSIS_ALTITUDE_SIZE = 377
    """Apoapsis Altitude - Size Parameter - Distance from the surface of the central body to the point of maximum radius in the orbit."""
    KEPLERIAN_APOAPSIS_RADIUS_SHAPE = 378
    """Apoapsis Radius - Shape Parameter - Distance from the center of the central body to the point of maximum radius in the orbit."""
    KEPLERIAN_APOAPSIS_RADIUS_SIZE = 379
    """Apoapsis Radius - Size Parameter - Distance from the center of the central body to the point of maximum radius in the orbit."""
    KEPLERIAN_ARGUMENT_LATITUDE = 380
    """Argument of Latitude - The sum of the True Anomaly and the Argument of Perigee."""
    KEPLERIAN_ECCENTRIC_ANOMALY = 381
    """Eccentric Anomaly - Angle measured with an origin at the center of the ellipse from the direction of perigee to a point on a circumscribing circle from which a line perpendicular to the SMA intersects the position of the satellite on the ellipse."""
    KEPLERIAN_LONGITUDE_OF_ASCENDING_NODE = 382
    """Longitude of Ascending Node - Longitude of the Ascending Node is the Earth-fixed longitude where the satellite has crossed the inertial equator from south to north based on an assumption of two-body motion."""
    KEPLERIAN_MEAN_ANOMALY = 383
    """Mean Anomaly - The angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate."""
    KEPLERIAN_MEAN_MOTION = 384
    """Mean Motion - The number of orbits per day (86400 sec/period), based on assumed two-body motion."""
    KEPLERIAN_PERIAPSIS_ALTITUDE_SHAPE = 385
    """Periapsis Altitude - Shape Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."""
    KEPLERIAN_PERIAPSIS_ALTITUDE_SIZE = 386
    """Periapsis Altitude - Size Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."""
    KEPLERIAN_PERIAPSIS_RADIUS_SHAPE = 387
    """Periapsis Radius - Shape Parameter - Distance from the center of the central body to the point of minimum radius in the orbit."""
    KEPLERIAN_PERIAPSIS_RADIUS_SIZE = 388
    """Periapsis Radius - Size Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."""
    KEPLERIAN_PERIOD = 389
    """Period - The duration of one orbit, based on assumed two-body motion."""
    KEPLERIAN_TIME_PAST_ASCENDING_NODE = 390
    """Time Past Ascending Node - The elapsed time since the last ascending node crossing based on assumed two-body motion."""
    KEPLERIAN_TIME_PAST_PERIAPSIS = 391
    """Time Past Periapsis - The elapsed time since the last perigee passage based on assumed two-body motion."""
    SPHERICAL_RANGE_RATE_DECLINATION = 392
    """Declination - the angle from the X-Y plane of the coordinate system to the spacecraft position vector."""
    SPHERICAL_RANGE_RATE_RIGHT_ASCENSION = 393
    """Right Ascension - angle measured in the inertial equatorial plane from the inertial X axis in a right-handed sense about the inertial Z axis to the spacecraft position vector."""
    SPHERICAL_RANGE_RATE_RANGE = 394
    """Range - distance of an object from the center point of the coordinate system."""
    SPHERICAL_RANGE_RATE_DECLINATION_RATE = 395
    """Declination Rate - the change of the declination angle over time."""
    SPHERICAL_RANGE_RATE_RIGHT_ASCENSION_RATE = 396
    """Right Ascension Rate - the change of the right ascension angle over time."""
    SPHERICAL_RANGE_RATE_RANGE_RATE = 397
    """Range Rate - the change in the range over time."""

ControlInitState.FUEL_MASS.__doc__ = "Fuel Mass - the mass of the spacecraft propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlInitState.CARTESIAN_VX.__doc__ = "Vx Component - the X component of the spacecraft velocity vector."
ControlInitState.CARTESIAN_VY.__doc__ = "Vy Component - the Y component of the spacecraft velocity vector."
ControlInitState.CARTESIAN_VZ.__doc__ = "Vz Component - the Z component of the spacecraft velocity vector."
ControlInitState.CARTESIAN_X.__doc__ = "X Component - the X component of the spacecraft position vector."
ControlInitState.CARTESIAN_Y.__doc__ = "Y Component - the Y component of the spacecraft position vector."
ControlInitState.CARTESIAN_Z.__doc__ = "Z Component - the Z component of the spacecraft position vector."
ControlInitState.CD.__doc__ = "Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."
ControlInitState.CR.__doc__ = "Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlInitState.DRAG_AREA.__doc__ = "Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Enter a value in the selected distance unit squared."
ControlInitState.DRY_MASS.__doc__ = "Dry Mass - the mass of the spacecraft exclusive of propellant. Enter a value in the selected mass unit (e.g. kg)."
ControlInitState.EPOCH.__doc__ = "Epoch - the orbit epoch."
ControlInitState.FUEL_DENSITY.__doc__ = "Fuel Density - the density of the fuel tank."
ControlInitState.K1.__doc__ = "GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."
ControlInitState.K2.__doc__ = "GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (Y bias) value."
ControlInitState.KEPLERIAN_ECCENTRICITY.__doc__ = "Eccentricity - the ratio of the distance between the foci to the major axis of the orbital ellipse. Dimensionless."
ControlInitState.KEPLERIAN_INCLINATION.__doc__ = "Inclination - the angle from the +Z axis of the coordinate system to the angular momentum vector of the spacecraft's orbit."
ControlInitState.KEPLERIAN_RAAN.__doc__ = "Right Ascension of Ascending Node - the angle between the X direction of the coordinate system and the point where the orbit crosses the X-Y plane in the +Z direction."
ControlInitState.KEPLERIAN_SEMIMAJOR_AXIS.__doc__ = "Semimajor Axis - half the length of the major (longest) axis of the orbital ellipse."
ControlInitState.KEPLERIAN_TRUE_ANOMALY.__doc__ = "True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."
ControlInitState.KEPLERIAN_W.__doc__ = "Argument of Periapsis - the angle measured in the direction of spacecraft motion, in the orbit plane, from the ascending node to the periapsis of the orbit."
ControlInitState.RADIATION_PRESSURE_AREA.__doc__ = "Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."
ControlInitState.CK.__doc__ = "Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlInitState.SPHERICAL_AZIMUTH.__doc__ = "Velocity Azimuth - the angle in the spacecraft local horizontal plane between the projection of the velocity vector onto that plane and the local +Z direction measured as positive in the clockwise direction from north."
ControlInitState.SPHERICAL_DECLINATION.__doc__ = "Declination - the angle from the X-Y plane of the coordinate system to the spacecraft position vector."
ControlInitState.SPHERICAL_HORIZONTAL_FLIGHT_PATH_ANGLE.__doc__ = "Horizontal Flight Path Angle - the complement of the angle between the spacecraft velocity vector and the radius vector (90 deg minus the vertical flight path angle)."
ControlInitState.SPHERICAL_RIGHT_ASCENSION.__doc__ = "Right Ascension - angle measured in the inertial equatorial plane from the inertial X axis in a right-handed sense about the inertial Z axis to the spacecraft position vector."
ControlInitState.SPHERICAL_RADIUS_MAGNITUDE.__doc__ = "Radius Magnitude - the magnitude of the spacecraft position vector."
ControlInitState.SPHERICAL_VELOCITY_MAGNITUDE.__doc__ = "Velocity Magnitude - the magnitude of the spacecraft velocity vector."
ControlInitState.SRP_AREA.__doc__ = "Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."
ControlInitState.TANK_PRESSURE.__doc__ = "Tank Pressure - the fuel tank pressure."
ControlInitState.TANK_TEMPERATURE.__doc__ = "Tank Temperature - the temperature of the fuel tank."
ControlInitState.TARGET_VECTOR_INCOMING_ASYMPTOTE_DECLINATION.__doc__ = "Declination of Incoming Asymptote - the declination of the incoming asymptote in the selected coordinate system."
ControlInitState.TARGET_VECTOR_INCOMING_ASYMPTOTE_RIGHT_ASCENSION.__doc__ = "Right Ascension of Incoming Asymptote - the right ascension of the hyperbolic incoming asymptote in the selected coordinate system."
ControlInitState.TARGET_VECTOR_INCOMING_VELOCITY_AZIMUTH_AT_PERIAPSIS.__doc__ = "Velocity Azimuth at Periapsis - the inertial flight path azimuth of the trajectory measured at periapsis."
ControlInitState.TARGET_VECTOR_INCOMING_C3.__doc__ = "C3 Energy - the energy of the orbit, computed as - mu / a, where mu is the gravity constant of the central body and a is the semimajor axis."
ControlInitState.TARGET_VECTOR_INCOMING_RADIUS_OF_PERIAPSIS.__doc__ = "Radius of Periapsis - distance from the center of mass of the central body to the periapsis of the hyperbolic orbit."
ControlInitState.TARGET_VECTOR_INCOMING_TRUE_ANOMALY.__doc__ = "True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."
ControlInitState.TARGET_VECTOR_OUTGOING_ASYMPTOTE_DECLINATION.__doc__ = "Declination of Outgoing Asymptote - the declination of the outgoing asymptote in the selected coordinate system."
ControlInitState.TARGET_VECTOR_OUTGOING_ASYMPTOTE_RIGHT_ASCENSION.__doc__ = "Right Ascension of Outgoing Asymptote - the right ascension of the hyperbolic outgoing asymptote in the selected coordinate system."
ControlInitState.TARGET_VECTOR_OUTGOING_VELOCITY_AZIMUTH_AT_PERIAPSIS.__doc__ = "Velocity Azimuth at Periapsis - the inertial flight path azimuth of the trajectory measured at periapsis."
ControlInitState.TARGET_VECTOR_OUTGOING_C3.__doc__ = "C3 Energy - the energy of the orbit, computed as - mu / a, where mu is the gravity constant of the central body and a is the semimajor axis."
ControlInitState.TARGET_VECTOR_OUTGOING_RADIUS_OF_PERIAPSIS.__doc__ = "Radius of Periapsis - distance from the center of mass of the central body to the periapsis of the hyperbolic orbit."
ControlInitState.TARGET_VECTOR_OUTGOING_TRUE_ANOMALY.__doc__ = "True Anomaly - the angle from the periapsis of the orbit to the spacecraft's position vector, measured in the direction of spacecraft motion."
ControlInitState.MAX_FUEL_MASS.__doc__ = "Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences."
ControlInitState.TANK_VOLUME.__doc__ = "Tank Volume - the volume of the fuel tank."
ControlInitState.DELAUNAY_G.__doc__ = "G - Magnitude of orbital angular momentum, (G: sqrt(GM * p))."
ControlInitState.DELAUNAY_H.__doc__ = "H - Z component of orbital angular momentum, (H: G cos(inc))."
ControlInitState.DELAUNAY_INCLINATION.__doc__ = "Inclination - The angle between the angular momentum vector (perpendicular to the plane of the orbit) and the inertial Z axis."
ControlInitState.DELAUNAY_L.__doc__ = "L - Related to two-body orbital energy, (L: sqrt(GM * a))."
ControlInitState.DELAUNAY_MEAN_ANOMALY.__doc__ = "Mean Anomaly - The angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate."
ControlInitState.DELAUNAY_RAAN.__doc__ = "Right Ascension of Ascending Node - The angle from the inertial X axis to the ascending node measured in a right-handed sense about the inertial Z axis in the equatorial plane."
ControlInitState.DELAUNAY_SEMILATUS_RECTUM.__doc__ = "Semi-latus Rectum - Distance from focus to orbit at true anomaly of 90 degrees."
ControlInitState.DELAUNAY_SEMIMAJOR_AXIS.__doc__ = "Semimajor Axis - Half the length of the major (longest) axis of the orbital ellipse."
ControlInitState.DELAUNAY_W.__doc__ = "Argument of Periapsis - The angle from the ascending node to the eccentricity vector measured in the direction of the satellite's motion and in the orbit plane."
ControlInitState.EQUINOCTIAL_H.__doc__ = "H - With K, describe the shape and position of periapsis of the orbit, (H: ecc * sin(RAAN + w))."
ControlInitState.EQUINOCTIAL_K.__doc__ = "K - With H, describe the shape and position of periapsis of the orbit, (K: ecc * cos(RAAN + w))."
ControlInitState.EQUINOCTIAL_MEAN_LONGITUDE.__doc__ = "Mean Longitude - (RAAN + w + M)."
ControlInitState.EQUINOCTIAL_MEAN_MOTION.__doc__ = "Mean Motion - The number of orbits per day (86400 sec/period), based on assumed two-body motion."
ControlInitState.EQUINOCTIAL_P.__doc__ = "P - With Q, describes the orientation of the orbit plane, (P: tan(inc/2) * sin(RAAN))."
ControlInitState.EQUINOCTIAL_Q.__doc__ = "Q - With P, describes the orientation of the orbit plane, (Q: tan(inc/2) * cos(RAAN))."
ControlInitState.EQUINOCTIAL_SEMIMAJOR_AXIS.__doc__ = "Semimajor Axis - Half the length of the major (longest) axis of the orbital ellipse."
ControlInitState.MIXED_SPHERICAL_ALTITUDE.__doc__ = "Altitude - The object's position above or below the reference ellipsoid. Altitude is measured along a normal to the surface of the reference ellipsoid."
ControlInitState.MIXED_SPHERICAL_AZIMUTH.__doc__ = "Azimuth - The angle in the satellite local horizontal plane between the projection of the inertial velocity vector onto this plane and the local north direction measured as positive in the clockwise direction."
ControlInitState.MIXED_SPHERICAL_HORIZONTAL_FLIGHT_PATH_ANGLE.__doc__ = "Horizontal Flight Path Angle - The complement of the angle between the inertial velocity vector and the radius vector."
ControlInitState.MIXED_SPHERICAL_LATITUDE.__doc__ = "Latitude - The geodetic latitude of a point is the angle between the normal to the reference ellipsoid that passes through the satellite position and the equatorial plane."
ControlInitState.MIXED_SPHERICAL_LONGITUDE.__doc__ = "Longitude."
ControlInitState.MIXED_SPHERICAL_VERTICAL_FLIGHT_PATH_ANGLE.__doc__ = "Vertical Flight Path Angle -  The angle between the inertial velocity vector and the radius vector."
ControlInitState.MIXED_SPHERICAL_V_MAGNITUDE.__doc__ = "Velocity Magnitude - The magnitude of the inertial velocity vector."
ControlInitState.SPHERICAL_VERTICAL_FLIGHT_PATH_ANGLE.__doc__ = "Vertical Flight Path Angle -  The angle between the inertial velocity vector and the radius vector."
ControlInitState.KEPLERIAN_APOAPSIS_ALTITUDE_SHAPE.__doc__ = "Apoapsis Altitude - Shape Parameter - Distance from the surface of the central body to the point of maximum radius in the orbit."
ControlInitState.KEPLERIAN_APOAPSIS_ALTITUDE_SIZE.__doc__ = "Apoapsis Altitude - Size Parameter - Distance from the surface of the central body to the point of maximum radius in the orbit."
ControlInitState.KEPLERIAN_APOAPSIS_RADIUS_SHAPE.__doc__ = "Apoapsis Radius - Shape Parameter - Distance from the center of the central body to the point of maximum radius in the orbit."
ControlInitState.KEPLERIAN_APOAPSIS_RADIUS_SIZE.__doc__ = "Apoapsis Radius - Size Parameter - Distance from the center of the central body to the point of maximum radius in the orbit."
ControlInitState.KEPLERIAN_ARGUMENT_LATITUDE.__doc__ = "Argument of Latitude - The sum of the True Anomaly and the Argument of Perigee."
ControlInitState.KEPLERIAN_ECCENTRIC_ANOMALY.__doc__ = "Eccentric Anomaly - Angle measured with an origin at the center of the ellipse from the direction of perigee to a point on a circumscribing circle from which a line perpendicular to the SMA intersects the position of the satellite on the ellipse."
ControlInitState.KEPLERIAN_LONGITUDE_OF_ASCENDING_NODE.__doc__ = "Longitude of Ascending Node - Longitude of the Ascending Node is the Earth-fixed longitude where the satellite has crossed the inertial equator from south to north based on an assumption of two-body motion."
ControlInitState.KEPLERIAN_MEAN_ANOMALY.__doc__ = "Mean Anomaly - The angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate."
ControlInitState.KEPLERIAN_MEAN_MOTION.__doc__ = "Mean Motion - The number of orbits per day (86400 sec/period), based on assumed two-body motion."
ControlInitState.KEPLERIAN_PERIAPSIS_ALTITUDE_SHAPE.__doc__ = "Periapsis Altitude - Shape Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."
ControlInitState.KEPLERIAN_PERIAPSIS_ALTITUDE_SIZE.__doc__ = "Periapsis Altitude - Size Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."
ControlInitState.KEPLERIAN_PERIAPSIS_RADIUS_SHAPE.__doc__ = "Periapsis Radius - Shape Parameter - Distance from the center of the central body to the point of minimum radius in the orbit."
ControlInitState.KEPLERIAN_PERIAPSIS_RADIUS_SIZE.__doc__ = "Periapsis Radius - Size Parameter - Distance from the surface of the central body to the point of minimum radius in the orbit."
ControlInitState.KEPLERIAN_PERIOD.__doc__ = "Period - The duration of one orbit, based on assumed two-body motion."
ControlInitState.KEPLERIAN_TIME_PAST_ASCENDING_NODE.__doc__ = "Time Past Ascending Node - The elapsed time since the last ascending node crossing based on assumed two-body motion."
ControlInitState.KEPLERIAN_TIME_PAST_PERIAPSIS.__doc__ = "Time Past Periapsis - The elapsed time since the last perigee passage based on assumed two-body motion."
ControlInitState.SPHERICAL_RANGE_RATE_DECLINATION.__doc__ = "Declination - the angle from the X-Y plane of the coordinate system to the spacecraft position vector."
ControlInitState.SPHERICAL_RANGE_RATE_RIGHT_ASCENSION.__doc__ = "Right Ascension - angle measured in the inertial equatorial plane from the inertial X axis in a right-handed sense about the inertial Z axis to the spacecraft position vector."
ControlInitState.SPHERICAL_RANGE_RATE_RANGE.__doc__ = "Range - distance of an object from the center point of the coordinate system."
ControlInitState.SPHERICAL_RANGE_RATE_DECLINATION_RATE.__doc__ = "Declination Rate - the change of the declination angle over time."
ControlInitState.SPHERICAL_RANGE_RATE_RIGHT_ASCENSION_RATE.__doc__ = "Right Ascension Rate - the change of the right ascension angle over time."
ControlInitState.SPHERICAL_RANGE_RATE_RANGE_RATE.__doc__ = "Range Rate - the change in the range over time."

agcls.AgTypeNameMap["ControlInitState"] = ControlInitState

class ControlManeuver(IntEnum):
    """Maneuver segment properties that can be selected as control parameters for a Target Sequence."""

    FINITE_CARTESIAN_X = 400
    """The Cartesian X component of the thrust vector."""
    FINITE_CARTESIAN_Y = 401
    """The Cartesian Y component of the thrust vector."""
    FINITE_CARTESIAN_Z = 402
    """The Cartesian Z component of the thrust vector."""
    FINITE_EULER_ANGLES1 = 403
    """The Euler A (Phi) component of the rotation from the reference axes to the body frame."""
    FINITE_EULER_ANGLES2 = 404
    """The Euler B (Theta) component of the rotation from the reference axes to the body frame."""
    FINITE_EULER_ANGLES3 = 405
    """The Euler C (Psi) component of the rotation from the reference axes to the body frame."""
    FINITE_SPHERICAL_AZIMUTH = 406
    """The spherical azimuth component of the thrust vector."""
    FINITE_SPHERICAL_ELEVATION = 407
    """The spherical elevation component of the thrust vector."""
    IMPULSIVE_CARTESIAN_X = 408
    """The Cartesian X component of the thrust vector."""
    IMPULSIVE_CARTESIAN_Y = 409
    """The Cartesian Y component of the thrust vector."""
    IMPULSIVE_CARTESIAN_Z = 410
    """The Cartesian Z component of the thrust vector."""
    IMPULSIVE_EULER_ANGLES1 = 411
    """The Euler A (Phi) component of the rotation from the reference axes to the body frame."""
    IMPULSIVE_EULER_ANGLES2 = 412
    """The Euler B (Theta) component of the rotation from the reference axes to the body frame."""
    IMPULSIVE_EULER_ANGLES3 = 413
    """The Euler C (Psi) component of the rotation from the reference axes to the body frame."""
    IMPULSIVE_SPHERICAL_AZIMUTH = 414
    """The spherical azimuth component of the thrust vector."""
    IMPULSIVE_SPHERICAL_ELEVATION = 415
    """The spherical elevation component of the thrust vector."""
    IMPULSIVE_SPHERICAL_MAGNITUDE = 416
    """The spherical magnitude component of the thrust vector."""
    FINITE_BURN_CENTER_BIAS = 417
    """The burn center bias of the thrust."""
    FINITE_THRUST_EFFICIENCY = 418
    """The thrust efficiency value."""
    FINITE_AZIMUTH_CONSTANT_TERM = 419
    """The time varying azimuth polynomial constant term."""
    FINITE_AZIMUTH_LINEAR_TERM = 420
    """The time varying azimuth polynomial linear term."""
    FINITE_AZIMUTH_QUADRATIC_TERM = 421
    """The time varying azimuth polynomial quadratic term."""
    FINITE_AZIMUTH_CUBIC_TERM = 422
    """The time varying azimuth polynomial cubic term."""
    FINITE_AZIMUTH_QUARTIC_TERM = 423
    """The time varying azimuth polynomial quartic term."""
    FINITE_AZIMUTH_SINUSOIDAL_AMPLITUDE = 424
    """The time varying azimuth sine amplitude term."""
    FINITE_AZIMUTH_SINUSOIDAL_FREQUENCY = 425
    """The time varying azimuth sine frequency term."""
    FINITE_AZIMUTH_SINUSOIDAL_PHASE = 426
    """The time varying azimuth sine phase term."""
    FINITE_ELEVATION_CONSTANT_TERM = 427
    """The time varying elevation polynomial constant term."""
    FINITE_ELEVATION_LINEAR_TERM = 428
    """The time varying elevation polynomial linear term."""
    FINITE_ELEVATION_QUADRATIC_TERM = 429
    """The time varying elevation polynomial quadratic term."""
    FINITE_ELEVATION_CUBIC_TERM = 430
    """The time varying elevation polynomial cubic term."""
    FINITE_ELEVATION_QUARTIC_TERM = 431
    """The time varying elevation polynomial quartic term."""
    FINITE_ELEVATION_SINUSOIDAL_AMPLITUDE = 432
    """The time varying elevation sine amplitude term."""
    FINITE_ELEVATION_SINUSOIDAL_FREQUENCY = 433
    """The time varying elevation sine frequency term."""
    FINITE_ELEVATION_SINUSOIDAL_PHASE = 434
    """The time varying elevation sine phase term."""

ControlManeuver.FINITE_CARTESIAN_X.__doc__ = "The Cartesian X component of the thrust vector."
ControlManeuver.FINITE_CARTESIAN_Y.__doc__ = "The Cartesian Y component of the thrust vector."
ControlManeuver.FINITE_CARTESIAN_Z.__doc__ = "The Cartesian Z component of the thrust vector."
ControlManeuver.FINITE_EULER_ANGLES1.__doc__ = "The Euler A (Phi) component of the rotation from the reference axes to the body frame."
ControlManeuver.FINITE_EULER_ANGLES2.__doc__ = "The Euler B (Theta) component of the rotation from the reference axes to the body frame."
ControlManeuver.FINITE_EULER_ANGLES3.__doc__ = "The Euler C (Psi) component of the rotation from the reference axes to the body frame."
ControlManeuver.FINITE_SPHERICAL_AZIMUTH.__doc__ = "The spherical azimuth component of the thrust vector."
ControlManeuver.FINITE_SPHERICAL_ELEVATION.__doc__ = "The spherical elevation component of the thrust vector."
ControlManeuver.IMPULSIVE_CARTESIAN_X.__doc__ = "The Cartesian X component of the thrust vector."
ControlManeuver.IMPULSIVE_CARTESIAN_Y.__doc__ = "The Cartesian Y component of the thrust vector."
ControlManeuver.IMPULSIVE_CARTESIAN_Z.__doc__ = "The Cartesian Z component of the thrust vector."
ControlManeuver.IMPULSIVE_EULER_ANGLES1.__doc__ = "The Euler A (Phi) component of the rotation from the reference axes to the body frame."
ControlManeuver.IMPULSIVE_EULER_ANGLES2.__doc__ = "The Euler B (Theta) component of the rotation from the reference axes to the body frame."
ControlManeuver.IMPULSIVE_EULER_ANGLES3.__doc__ = "The Euler C (Psi) component of the rotation from the reference axes to the body frame."
ControlManeuver.IMPULSIVE_SPHERICAL_AZIMUTH.__doc__ = "The spherical azimuth component of the thrust vector."
ControlManeuver.IMPULSIVE_SPHERICAL_ELEVATION.__doc__ = "The spherical elevation component of the thrust vector."
ControlManeuver.IMPULSIVE_SPHERICAL_MAGNITUDE.__doc__ = "The spherical magnitude component of the thrust vector."
ControlManeuver.FINITE_BURN_CENTER_BIAS.__doc__ = "The burn center bias of the thrust."
ControlManeuver.FINITE_THRUST_EFFICIENCY.__doc__ = "The thrust efficiency value."
ControlManeuver.FINITE_AZIMUTH_CONSTANT_TERM.__doc__ = "The time varying azimuth polynomial constant term."
ControlManeuver.FINITE_AZIMUTH_LINEAR_TERM.__doc__ = "The time varying azimuth polynomial linear term."
ControlManeuver.FINITE_AZIMUTH_QUADRATIC_TERM.__doc__ = "The time varying azimuth polynomial quadratic term."
ControlManeuver.FINITE_AZIMUTH_CUBIC_TERM.__doc__ = "The time varying azimuth polynomial cubic term."
ControlManeuver.FINITE_AZIMUTH_QUARTIC_TERM.__doc__ = "The time varying azimuth polynomial quartic term."
ControlManeuver.FINITE_AZIMUTH_SINUSOIDAL_AMPLITUDE.__doc__ = "The time varying azimuth sine amplitude term."
ControlManeuver.FINITE_AZIMUTH_SINUSOIDAL_FREQUENCY.__doc__ = "The time varying azimuth sine frequency term."
ControlManeuver.FINITE_AZIMUTH_SINUSOIDAL_PHASE.__doc__ = "The time varying azimuth sine phase term."
ControlManeuver.FINITE_ELEVATION_CONSTANT_TERM.__doc__ = "The time varying elevation polynomial constant term."
ControlManeuver.FINITE_ELEVATION_LINEAR_TERM.__doc__ = "The time varying elevation polynomial linear term."
ControlManeuver.FINITE_ELEVATION_QUADRATIC_TERM.__doc__ = "The time varying elevation polynomial quadratic term."
ControlManeuver.FINITE_ELEVATION_CUBIC_TERM.__doc__ = "The time varying elevation polynomial cubic term."
ControlManeuver.FINITE_ELEVATION_QUARTIC_TERM.__doc__ = "The time varying elevation polynomial quartic term."
ControlManeuver.FINITE_ELEVATION_SINUSOIDAL_AMPLITUDE.__doc__ = "The time varying elevation sine amplitude term."
ControlManeuver.FINITE_ELEVATION_SINUSOIDAL_FREQUENCY.__doc__ = "The time varying elevation sine frequency term."
ControlManeuver.FINITE_ELEVATION_SINUSOIDAL_PHASE.__doc__ = "The time varying elevation sine phase term."

agcls.AgTypeNameMap["ControlManeuver"] = ControlManeuver

class ControlLaunch(IntEnum):
    """Launch segment properties that can be selected as control parameters for a Target Sequence."""

    EPOCH = 500
    """The date and time of the launch."""
    GEODETIC_LATITUDE = 501
    """The geodetic latitude of the launch location."""
    GEODETIC_LONGITUDE = 502
    """The geodetic longitude of the launch location."""
    GEODETIC_ALTITUDE = 503
    """The geodetic altitude of the launch location."""
    GEOCENTRIC_LATITUDE = 504
    """The geocentric latitude of the launch location."""
    GEOCENTRIC_LONGITUDE = 505
    """The geocentric longitude of the launch location."""
    GEOCENTRIC_RADIUS = 506
    """The geocentric radius of the launch location."""
    TIME_OF_FLIGHT = 507
    """The time of flight, from launch until burnout."""
    BURNOUT_GEOCENTRIC_LATITUDE = 508
    """The geocentric latitude of the burnout point."""
    BURNOUT_GEOCENTRIC_LONGITUDE = 509
    """The geocentric longitude of the burnout point."""
    BURNOUT_GEOCENTRIC_RADIUS = 510
    """The geocentric radius of the burnout point."""
    BURNOUT_GEODETIC_LATITUDE = 511
    """The geodetic latitude of the burnout point."""
    BURNOUT_GEODETIC_LONGITUDE = 512
    """The geodetic longitude of the burnout point."""
    BURNOUT_GEODETIC_ALTITUDE = 513
    """The geodetic altitude of the burnout point."""
    BURNOUT_AZIMUTH_ALTITUDE_AZIMUTH = 514
    """The geodetic azimuth of the launch trajectory."""
    BURNOUT_AZIMUTH_ALTITUDE_DOWNRANGE_DIST = 515
    """The geodetic downrange distance of the burnout point."""
    BURNOUT_AZIMUTH_ALTITUDE_ALTITUDE = 516
    """The geodetic altitude of the burnout point."""
    BURNOUT_AZIMUTH_RADIUS_AZIMUTH = 517
    """The geocentric azimuth of the launch trajectory."""
    BURNOUT_AZIMUTH_RADIUS_DOWNRANGE_DIST = 518
    """The geocentric downrange distance of the burnout point."""
    BURNOUT_AZIMUTH_RADIUS_RADIUS = 519
    """The geocentric radius of the burnout point."""
    BURNOUT_FIXED_VELOCITY = 520
    """The burnout velocity in the fixed frame."""
    BURNOUT_INERTIAL_VELOCITY = 521
    """The burnout velocity in the inertial frame."""
    BURNOUT_INERTIAL_VELOCITY_AZIMUTH = 522
    """Inertial Velocity Azimuth - the angle from the projection of north in the local horizontal plane to the inertial velocity vector, right handed."""
    BURNOUT_INERTIAL_HORIZONTAL_FLIGHT_PATH_ANGLE = 523
    """Inertial Horizontal FPA - the angle from the local horizontal to the inertial velocity vector, positive towards radius. It is also 90 degrees minus vertical flight path angle."""
    DRY_MASS = 524
    """Dry Mass - the mass of the spacecraft exclusive of propellant."""
    CD = 525
    """Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."""
    DRAG_AREA = 526
    """Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations."""
    CR = 527
    """Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    SRP_AREA = 528
    """Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."""
    CK = 529
    """Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    RADIATION_PRESSURE_AREA = 530
    """Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."""
    K1 = 531
    """GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."""
    K2 = 532
    """GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (scale) value."""
    TANK_PRESSURE = 533
    """The fuel tank pressure."""
    TANK_VOLUME = 534
    """The volume of the fuel tank."""
    TANK_TEMP = 535
    """The fuel tank temperature."""
    FUEL_DENSITY = 536
    """The density of the fuel tank."""
    FUEL_MASS = 537
    """The mass of the spacecraft propellant."""
    MAX_FUEL_MASS = 538
    """Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences."""

ControlLaunch.EPOCH.__doc__ = "The date and time of the launch."
ControlLaunch.GEODETIC_LATITUDE.__doc__ = "The geodetic latitude of the launch location."
ControlLaunch.GEODETIC_LONGITUDE.__doc__ = "The geodetic longitude of the launch location."
ControlLaunch.GEODETIC_ALTITUDE.__doc__ = "The geodetic altitude of the launch location."
ControlLaunch.GEOCENTRIC_LATITUDE.__doc__ = "The geocentric latitude of the launch location."
ControlLaunch.GEOCENTRIC_LONGITUDE.__doc__ = "The geocentric longitude of the launch location."
ControlLaunch.GEOCENTRIC_RADIUS.__doc__ = "The geocentric radius of the launch location."
ControlLaunch.TIME_OF_FLIGHT.__doc__ = "The time of flight, from launch until burnout."
ControlLaunch.BURNOUT_GEOCENTRIC_LATITUDE.__doc__ = "The geocentric latitude of the burnout point."
ControlLaunch.BURNOUT_GEOCENTRIC_LONGITUDE.__doc__ = "The geocentric longitude of the burnout point."
ControlLaunch.BURNOUT_GEOCENTRIC_RADIUS.__doc__ = "The geocentric radius of the burnout point."
ControlLaunch.BURNOUT_GEODETIC_LATITUDE.__doc__ = "The geodetic latitude of the burnout point."
ControlLaunch.BURNOUT_GEODETIC_LONGITUDE.__doc__ = "The geodetic longitude of the burnout point."
ControlLaunch.BURNOUT_GEODETIC_ALTITUDE.__doc__ = "The geodetic altitude of the burnout point."
ControlLaunch.BURNOUT_AZIMUTH_ALTITUDE_AZIMUTH.__doc__ = "The geodetic azimuth of the launch trajectory."
ControlLaunch.BURNOUT_AZIMUTH_ALTITUDE_DOWNRANGE_DIST.__doc__ = "The geodetic downrange distance of the burnout point."
ControlLaunch.BURNOUT_AZIMUTH_ALTITUDE_ALTITUDE.__doc__ = "The geodetic altitude of the burnout point."
ControlLaunch.BURNOUT_AZIMUTH_RADIUS_AZIMUTH.__doc__ = "The geocentric azimuth of the launch trajectory."
ControlLaunch.BURNOUT_AZIMUTH_RADIUS_DOWNRANGE_DIST.__doc__ = "The geocentric downrange distance of the burnout point."
ControlLaunch.BURNOUT_AZIMUTH_RADIUS_RADIUS.__doc__ = "The geocentric radius of the burnout point."
ControlLaunch.BURNOUT_FIXED_VELOCITY.__doc__ = "The burnout velocity in the fixed frame."
ControlLaunch.BURNOUT_INERTIAL_VELOCITY.__doc__ = "The burnout velocity in the inertial frame."
ControlLaunch.BURNOUT_INERTIAL_VELOCITY_AZIMUTH.__doc__ = "Inertial Velocity Azimuth - the angle from the projection of north in the local horizontal plane to the inertial velocity vector, right handed."
ControlLaunch.BURNOUT_INERTIAL_HORIZONTAL_FLIGHT_PATH_ANGLE.__doc__ = "Inertial Horizontal FPA - the angle from the local horizontal to the inertial velocity vector, positive towards radius. It is also 90 degrees minus vertical flight path angle."
ControlLaunch.DRY_MASS.__doc__ = "Dry Mass - the mass of the spacecraft exclusive of propellant."
ControlLaunch.CD.__doc__ = "Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."
ControlLaunch.DRAG_AREA.__doc__ = "Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations."
ControlLaunch.CR.__doc__ = "Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlLaunch.SRP_AREA.__doc__ = "Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."
ControlLaunch.CK.__doc__ = "Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
ControlLaunch.RADIATION_PRESSURE_AREA.__doc__ = "Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."
ControlLaunch.K1.__doc__ = "GPS Solar Radiation Pressure K1 - if you are using a non-spherical SRP model, this field defines the model's K1 (scale) value."
ControlLaunch.K2.__doc__ = "GPS Solar Radiation Pressure K2 - if you are using a non-spherical SRP model, this field defines the model's K2 (scale) value."
ControlLaunch.TANK_PRESSURE.__doc__ = "The fuel tank pressure."
ControlLaunch.TANK_VOLUME.__doc__ = "The volume of the fuel tank."
ControlLaunch.TANK_TEMP.__doc__ = "The fuel tank temperature."
ControlLaunch.FUEL_DENSITY.__doc__ = "The density of the fuel tank."
ControlLaunch.FUEL_MASS.__doc__ = "The mass of the spacecraft propellant."
ControlLaunch.MAX_FUEL_MASS.__doc__ = "Maximum Fuel Mass - the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences."

agcls.AgTypeNameMap["ControlLaunch"] = ControlLaunch

class ControlAdvanced(IntEnum):
    """Propagate segment properties that can be selected as control parameters for a Target Sequence."""

    PROPAGATE_MAX_PROPATION_TIME = 600
    """The maximum propagation time, after which the segment will end regardless of whether the stopping conditions have been satisfied."""
    PROPAGATE_MIN_PROPAGATION_TIME = 601
    """The minimum propagation time - minimum time that must elapse from the beginning of the segment until Astrogator will begin checking stopping conditions for satisfaction."""

ControlAdvanced.PROPAGATE_MAX_PROPATION_TIME.__doc__ = "The maximum propagation time, after which the segment will end regardless of whether the stopping conditions have been satisfied."
ControlAdvanced.PROPAGATE_MIN_PROPAGATION_TIME.__doc__ = "The minimum propagation time - minimum time that must elapse from the beginning of the segment until Astrogator will begin checking stopping conditions for satisfaction."

agcls.AgTypeNameMap["ControlAdvanced"] = ControlAdvanced

class TargetSequenceAction(IntEnum):
    """Action options for Target Sequence profiles."""

    RUN_NOMINAL_SEQUENCE = 0
    """Run Nominal Sequence - runs the mission control sequence."""
    RUN_ACTIVE_PROFILES = 1
    """Run Active Profiles - runs the mission control sequence allowing the active profiles to operate."""
    RUN_ACTIVE_PROFILES_ONCE = 2
    """Run Active Profiles Once - runs the profile with corrections applied to control parameters."""

TargetSequenceAction.RUN_NOMINAL_SEQUENCE.__doc__ = "Run Nominal Sequence - runs the mission control sequence."
TargetSequenceAction.RUN_ACTIVE_PROFILES.__doc__ = "Run Active Profiles - runs the mission control sequence allowing the active profiles to operate."
TargetSequenceAction.RUN_ACTIVE_PROFILES_ONCE.__doc__ = "Run Active Profiles Once - runs the profile with corrections applied to control parameters."

agcls.AgTypeNameMap["TargetSequenceAction"] = TargetSequenceAction

class ProfilesFinish(IntEnum):
    """Action options for Target Sequence profiles convergence."""

    RUN_TO_RETURN_AND_CONTINUE = 0
    """Run To Return And Continue - run to the first Return segment in the sequence, then pass control to the next segment after this target sequence. Often, the only Return is at the end of the target sequence."""
    RUN_TO_RETURN_AND_STOP = 1
    """Run To Return And Stop - run the target sequence to the first Return segment, and then stop running the MCS altogether."""
    STOP = 2
    """Stop - stop the MCS as soon as the target sequence has converged."""

ProfilesFinish.RUN_TO_RETURN_AND_CONTINUE.__doc__ = "Run To Return And Continue - run to the first Return segment in the sequence, then pass control to the next segment after this target sequence. Often, the only Return is at the end of the target sequence."
ProfilesFinish.RUN_TO_RETURN_AND_STOP.__doc__ = "Run To Return And Stop - run the target sequence to the first Return segment, and then stop running the MCS altogether."
ProfilesFinish.STOP.__doc__ = "Stop - stop the MCS as soon as the target sequence has converged."

agcls.AgTypeNameMap["ProfilesFinish"] = ProfilesFinish

class UpdateParam(IntEnum):
    """Spacecraft parameters that can be modified by an Update segment."""

    DRAG_AREA = 0
    """Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations."""
    SRP_AREA = 1
    """Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."""
    DRY_MASS = 2
    """Dry Mass - the mass of the spacecraft exclusive of propellant."""
    FUEL_MASS = 3
    """The mass of the spacecraft propellant."""
    FUEL_DENSITY = 4
    """The density of the fuel tank."""
    TANK_PRESSURE = 5
    """The fuel tank pressure."""
    TANK_TEMPERATURE = 6
    """The temperature of the fuel tank."""
    CR = 7
    """Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    CD = 8
    """Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."""
    CK = 9
    """Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."""
    RADIATION_PRESSURE_AREA = 10
    """Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."""

UpdateParam.DRAG_AREA.__doc__ = "Drag Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations."
UpdateParam.SRP_AREA.__doc__ = "Solar Radiation Pressure (Spherical) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations."
UpdateParam.DRY_MASS.__doc__ = "Dry Mass - the mass of the spacecraft exclusive of propellant."
UpdateParam.FUEL_MASS.__doc__ = "The mass of the spacecraft propellant."
UpdateParam.FUEL_DENSITY.__doc__ = "The density of the fuel tank."
UpdateParam.TANK_PRESSURE.__doc__ = "The fuel tank pressure."
UpdateParam.TANK_TEMPERATURE.__doc__ = "The temperature of the fuel tank."
UpdateParam.CR.__doc__ = "Solar Radiation Pressure (Spherical) Coefficient (Cr) - the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
UpdateParam.CD.__doc__ = "Drag Coefficient (Cd) - the dimensionless drag coefficient associated with the drag area."
UpdateParam.CK.__doc__ = "Radiation Pressure (Albedo/Thermal) Coefficient (Ck) - the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all."
UpdateParam.RADIATION_PRESSURE_AREA.__doc__ = "Radiation Pressure (Albedo/Thermal) Area - the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations."

agcls.AgTypeNameMap["UpdateParam"] = UpdateParam

class UpdateAction(IntEnum):
    """Actions for the Update segment."""

    NO_CHANGE = 0
    """No change in value - leave the current value for this parameter unchanged (ignoring any quantity that may appear in the Value column)."""
    ADD_VALUE = 1
    """Add value - add the quantity entered in the Value column to the current value for this parameter."""
    SUBTRACT_VALUE = 2
    """Subtract value - subtract the quantity entered in the Value column from the current value for this parameter."""
    SET_TO_NEW_VALUE = 3
    """Set to new value - replace the current value for this parameter with the quantity entered in the Value column."""

UpdateAction.NO_CHANGE.__doc__ = "No change in value - leave the current value for this parameter unchanged (ignoring any quantity that may appear in the Value column)."
UpdateAction.ADD_VALUE.__doc__ = "Add value - add the quantity entered in the Value column to the current value for this parameter."
UpdateAction.SUBTRACT_VALUE.__doc__ = "Subtract value - subtract the quantity entered in the Value column from the current value for this parameter."
UpdateAction.SET_TO_NEW_VALUE.__doc__ = "Set to new value - replace the current value for this parameter with the quantity entered in the Value column."

agcls.AgTypeNameMap["UpdateAction"] = UpdateAction

class PressureMode(IntEnum):
    """Pressure Mode options."""

    BLOW_DOWN = 0
    """Blow-Down - pressure decreases as propellant is consumed and the volume occupied by the pressurant gas consequently increases. This is based on the ideal gas law."""
    PRESSURE_REGULATED = 1
    """Pressure-Regulated - constant pressure is maintained in the fuel tank through some pressurization mechanism as the propellant mass decreases."""

PressureMode.BLOW_DOWN.__doc__ = "Blow-Down - pressure decreases as propellant is consumed and the volume occupied by the pressurant gas consequently increases. This is based on the ideal gas law."
PressureMode.PRESSURE_REGULATED.__doc__ = "Pressure-Regulated - constant pressure is maintained in the fuel tank through some pressurization mechanism as the propellant mass decreases."

agcls.AgTypeNameMap["PressureMode"] = PressureMode

class ThrustType(IntEnum):
    """Thrust options."""

    AFFECTS_ACCELERATION_AND_MASS_FLOW = 0
    """Affects Acceleration and Mass Flow Calculations - may represent an inefficiency in the propulsion tanks and feed lines."""
    AFFECTS_ACCELERATION_ONLY = 1
    """Affects Acceleration Only - an efficiency of 0.98 means that only 98% of the fuel will be spent to get 98% thrust. For example, a thrust efficiency affecting acceleration only may represent some problem in the combustion chamber."""

ThrustType.AFFECTS_ACCELERATION_AND_MASS_FLOW.__doc__ = "Affects Acceleration and Mass Flow Calculations - may represent an inefficiency in the propulsion tanks and feed lines."
ThrustType.AFFECTS_ACCELERATION_ONLY.__doc__ = "Affects Acceleration Only - an efficiency of 0.98 means that only 98% of the fuel will be spent to get 98% thrust. For example, a thrust efficiency affecting acceleration only may represent some problem in the combustion chamber."

agcls.AgTypeNameMap["ThrustType"] = ThrustType

class AttitudeUpdate(IntEnum):
    """Attitude Update."""

    DURING_BURN = 0
    """Update during burn - updated throughout the maneuver so as to maintain the required thrust direction. This forces the thrust vector to the specified direction at every instant throughout the burn."""
    INERTIAL_AT_IGNITION = 1
    """Inertial at ignition - specified by Attitude Control at ignition and remains the same throughout the maneuver. This fixes the thrust direction in the inertial direction calculated at the beginning of the burn and is used for inertially fixed spacecraft."""
    INERTIAL_AT_START = 2
    """Inertial at start - specified by Attitude Control at the beginning of the maneuver segment and remains the same throughout the maneuver."""

AttitudeUpdate.DURING_BURN.__doc__ = "Update during burn - updated throughout the maneuver so as to maintain the required thrust direction. This forces the thrust vector to the specified direction at every instant throughout the burn."
AttitudeUpdate.INERTIAL_AT_IGNITION.__doc__ = "Inertial at ignition - specified by Attitude Control at ignition and remains the same throughout the maneuver. This fixes the thrust direction in the inertial direction calculated at the beginning of the burn and is used for inertially fixed spacecraft."
AttitudeUpdate.INERTIAL_AT_START.__doc__ = "Inertial at start - specified by Attitude Control at the beginning of the maneuver segment and remains the same throughout the maneuver."

agcls.AgTypeNameMap["AttitudeUpdate"] = AttitudeUpdate

class PropulsionMethod(IntEnum):
    """Propulsion method options."""

    ENGINE_MODEL = 0
    """Engine Model - can be used to quickly model the firing of a single engine."""
    THRUSTER_SET = 1
    """Thruster Set - used to fire multiple engines simultaneously, and to simulate off-pulsing or complex engine pointing."""

PropulsionMethod.ENGINE_MODEL.__doc__ = "Engine Model - can be used to quickly model the firing of a single engine."
PropulsionMethod.THRUSTER_SET.__doc__ = "Thruster Set - used to fire multiple engines simultaneously, and to simulate off-pulsing or complex engine pointing."

agcls.AgTypeNameMap["PropulsionMethod"] = PropulsionMethod

class CustomFunction(IntEnum):
    """Attitude definition options for other STK functions."""

    ENABLE_PAGE_DEFINITION = 0
    """Use attitude page definition for other STK functions - the actual attitude during the maneuver is ignored and the satellite is considered to always be in the attitude specified by the page for all other calculations in STK."""
    ENABLE_MANEUVER_ATTITUDE = 1
    """Maneuver attitude will be used for the satellite during the time at the maneuver, and during the specified lead and trail times. This attitude will also show up in reports, graphs, sensor access calculations, and in the 3D Graphics window."""

CustomFunction.ENABLE_PAGE_DEFINITION.__doc__ = "Use attitude page definition for other STK functions - the actual attitude during the maneuver is ignored and the satellite is considered to always be in the attitude specified by the page for all other calculations in STK."
CustomFunction.ENABLE_MANEUVER_ATTITUDE.__doc__ = "Maneuver attitude will be used for the satellite during the time at the maneuver, and during the specified lead and trail times. This attitude will also show up in reports, graphs, sensor access calculations, and in the 3D Graphics window."

agcls.AgTypeNameMap["CustomFunction"] = CustomFunction

class BodyAxis(IntEnum):
    """Attitude body axis options."""

    PLUS_X = 0
    """The positive X engine acceleration direction."""
    PLUS_Y = 1
    """The positive Y engine acceleration direction."""
    PLUS_Z = 2
    """The positive Z engine acceleration direction."""
    MINUS_X = 3
    """The negative X engine acceleration direction."""
    MINUS_Y = 4
    """The negative Y engine acceleration direction."""
    MINUS_Z = 5
    """The negative Z engine acceleration direction."""

BodyAxis.PLUS_X.__doc__ = "The positive X engine acceleration direction."
BodyAxis.PLUS_Y.__doc__ = "The positive Y engine acceleration direction."
BodyAxis.PLUS_Z.__doc__ = "The positive Z engine acceleration direction."
BodyAxis.MINUS_X.__doc__ = "The negative X engine acceleration direction."
BodyAxis.MINUS_Y.__doc__ = "The negative Y engine acceleration direction."
BodyAxis.MINUS_Z.__doc__ = "The negative Z engine acceleration direction."

agcls.AgTypeNameMap["BodyAxis"] = BodyAxis

class ConstraintSign(IntEnum):
    """Constraint vector sign options."""

    PLUS = 0
    """Positive."""
    MINUS = 1
    """Negative."""

ConstraintSign.PLUS.__doc__ = "Positive."
ConstraintSign.MINUS.__doc__ = "Negative."

agcls.AgTypeNameMap["ConstraintSign"] = ConstraintSign

class AttitudeControl(IntEnum):
    """Attitude Control options."""

    VELOCITY_VECTOR = 0
    """Along Velocity Vector (impulsive/finite) - the total thrust vector is aligned with the spacecraft's velocity vector."""
    ANTI_VELOCITY_VECTOR = 1
    """Anti-Velocity Vector (impulsive/finite) - the total thrust vector is opposite to the spacecraft's velocity vector."""
    ATTITUDE = 2
    """Attitude (impulsive/finite) - the thrust vector direction is defined using Euler Angles or a Quaternion."""
    FILE = 3
    """File (impulsive/finite) - uses an attitude file to set the thrust vector direction."""
    THRUST_VECTOR = 4
    """Thrust Vector (impulsive/finite) - the total thrust vector is explicitly specified in Cartesian or spherical form with respect to the thrust axes."""
    PLUGIN = 5
    """Plugin (finite) - thrust vector direction is defined using a COM plugin."""
    TIME_VARYING = 6
    """Time Varying (finite) - polynomial and sine representations for the azimuth and elevation of the thrust vector."""
    LAGRANGE_INTERPOLATION = 7
    """Lagrange Interpolation (optimal finite, always set) - supports the 'Run current nodes' execution mode of the Optimal Finite Maneuver."""

AttitudeControl.VELOCITY_VECTOR.__doc__ = "Along Velocity Vector (impulsive/finite) - the total thrust vector is aligned with the spacecraft's velocity vector."
AttitudeControl.ANTI_VELOCITY_VECTOR.__doc__ = "Anti-Velocity Vector (impulsive/finite) - the total thrust vector is opposite to the spacecraft's velocity vector."
AttitudeControl.ATTITUDE.__doc__ = "Attitude (impulsive/finite) - the thrust vector direction is defined using Euler Angles or a Quaternion."
AttitudeControl.FILE.__doc__ = "File (impulsive/finite) - uses an attitude file to set the thrust vector direction."
AttitudeControl.THRUST_VECTOR.__doc__ = "Thrust Vector (impulsive/finite) - the total thrust vector is explicitly specified in Cartesian or spherical form with respect to the thrust axes."
AttitudeControl.PLUGIN.__doc__ = "Plugin (finite) - thrust vector direction is defined using a COM plugin."
AttitudeControl.TIME_VARYING.__doc__ = "Time Varying (finite) - polynomial and sine representations for the azimuth and elevation of the thrust vector."
AttitudeControl.LAGRANGE_INTERPOLATION.__doc__ = "Lagrange Interpolation (optimal finite, always set) - supports the 'Run current nodes' execution mode of the Optimal Finite Maneuver."

agcls.AgTypeNameMap["AttitudeControl"] = AttitudeControl

class FollowJoin(IntEnum):
    """Joining options for the Follow segment."""

    SPECIFY = 0
    """Specify Joining Conditions - specify joining conditions to define when the spacecraft will begin to follow the leader. Joining conditions will become apparent on a new tab - Joining."""
    AT_BEGINNING = 1
    """Join at Beginning of Leader's Ephemeris - the spacecraft will follow the leader from the beginning of the leader's ephemeris."""
    AT_END = 2
    """Join at End of Leader's Ephemeris - the spacecraft will use the leader's final ephemeris point as the initial and final state of the Follow segment; the separation parameter will automatically be set to 'Separate at End of Leader's Ephemeris'."""
    AT_FINAL_EPOCH_OF_PREVIOUS_SEG = 3
    """Join at Final Epoch of Previous Segment - the spacecraft will follow the leader from the final epoch at the end of the previous segment."""

FollowJoin.SPECIFY.__doc__ = "Specify Joining Conditions - specify joining conditions to define when the spacecraft will begin to follow the leader. Joining conditions will become apparent on a new tab - Joining."
FollowJoin.AT_BEGINNING.__doc__ = "Join at Beginning of Leader's Ephemeris - the spacecraft will follow the leader from the beginning of the leader's ephemeris."
FollowJoin.AT_END.__doc__ = "Join at End of Leader's Ephemeris - the spacecraft will use the leader's final ephemeris point as the initial and final state of the Follow segment; the separation parameter will automatically be set to 'Separate at End of Leader's Ephemeris'."
FollowJoin.AT_FINAL_EPOCH_OF_PREVIOUS_SEG.__doc__ = "Join at Final Epoch of Previous Segment - the spacecraft will follow the leader from the final epoch at the end of the previous segment."

agcls.AgTypeNameMap["FollowJoin"] = FollowJoin

class FollowSeparation(IntEnum):
    """Separation options for the Follow segment."""

    SPECIFY = 0
    """Specify Separation Conditions - specify separation conditions to define when the spacecraft will stop following the leader. Separation conditions will become apparent on a new tab - Separation."""
    AT_END_OF_LEADERS_EPHEMERIS = 1
    """Separate at End of Leader's Ephemeris - the spacecraft will follow the leader to the end of the leader's ephemeris and then separate."""

FollowSeparation.SPECIFY.__doc__ = "Specify Separation Conditions - specify separation conditions to define when the spacecraft will stop following the leader. Separation conditions will become apparent on a new tab - Separation."
FollowSeparation.AT_END_OF_LEADERS_EPHEMERIS.__doc__ = "Separate at End of Leader's Ephemeris - the spacecraft will follow the leader to the end of the leader's ephemeris and then separate."

agcls.AgTypeNameMap["FollowSeparation"] = FollowSeparation

class FollowSpacecraftAndFuelTank(IntEnum):
    """Spacecraft parameter options for the Follow segment."""

    SPECIFY = 0
    """Specify Spacecraft Configuration - manually define the spacecraft for this segment. Spacecraft physical parameters will become apparent on new tabs - Spacecraft Parameters and Fuel Tank."""
    INHERIT = 1
    """Inherit Spacecraft Configuration From Previous Segment - the spacecraft will be defined by its configuration at the end of the previous segment. The configuration will not be changed by the Follow segment."""
    LEADER = 2
    """Inherit Spacecraft Configuration From Leader - if leader is an Astrogator satellite, configuration will be defined by the leader's configuration."""

FollowSpacecraftAndFuelTank.SPECIFY.__doc__ = "Specify Spacecraft Configuration - manually define the spacecraft for this segment. Spacecraft physical parameters will become apparent on new tabs - Spacecraft Parameters and Fuel Tank."
FollowSpacecraftAndFuelTank.INHERIT.__doc__ = "Inherit Spacecraft Configuration From Previous Segment - the spacecraft will be defined by its configuration at the end of the previous segment. The configuration will not be changed by the Follow segment."
FollowSpacecraftAndFuelTank.LEADER.__doc__ = "Inherit Spacecraft Configuration From Leader - if leader is an Astrogator satellite, configuration will be defined by the leader's configuration."

agcls.AgTypeNameMap["FollowSpacecraftAndFuelTank"] = FollowSpacecraftAndFuelTank

class BurnoutOptions(IntEnum):
    """Burnout options for the Launch segment."""

    FIXED_VELOCITY = 0
    """Use Fixed Velocity - the inclination of the final state of the launch segment is determined by the arc between the launch and insertion positions, and the horizontal flight path angle is set to zero."""
    INERTIAL_VELOCITY = 1
    """Use Inertial Velocity - the final state of the launch segment is solely and completely determined by the burnout position and velocity."""

BurnoutOptions.FIXED_VELOCITY.__doc__ = "Use Fixed Velocity - the inclination of the final state of the launch segment is determined by the arc between the launch and insertion positions, and the horizontal flight path angle is set to zero."
BurnoutOptions.INERTIAL_VELOCITY.__doc__ = "Use Inertial Velocity - the final state of the launch segment is solely and completely determined by the burnout position and velocity."

agcls.AgTypeNameMap["BurnoutOptions"] = BurnoutOptions

class BurnoutType(IntEnum):
    """Burnout point definition types for the Launch segment."""

    GEOCENTRIC = 0
    """Geocentric (Planetocentric) - the burnout point is measured from the center of mass of the Earth or other central body."""
    GEODETIC = 1
    """Geodetic (Planetodetic) - the burnout point is measured along the normal to the surface of an ellipsoid defined with reference to the Earth (or other central body)."""
    LAUNCH_AZIMUTH_RADIUS = 2
    """Launch Az / Radius - the burnout point is defined in reference to distance downrange along an azimuth, measured from the center of mass of the Earth or other central body."""
    LAUNCH_AZIMUTH_ALTITUDE = 3
    """Launch Az / Alt - the burnout point is defined in reference to distance downrange along an azimuth, measured from the surface of the Earth or other central body."""
    CBF_CARTESIAN = 4
    """Central Body Fixed Cartesian - the burnout state is specified in the central-body-fixed Cartesian coordinate system."""

BurnoutType.GEOCENTRIC.__doc__ = "Geocentric (Planetocentric) - the burnout point is measured from the center of mass of the Earth or other central body."
BurnoutType.GEODETIC.__doc__ = "Geodetic (Planetodetic) - the burnout point is measured along the normal to the surface of an ellipsoid defined with reference to the Earth (or other central body)."
BurnoutType.LAUNCH_AZIMUTH_RADIUS.__doc__ = "Launch Az / Radius - the burnout point is defined in reference to distance downrange along an azimuth, measured from the center of mass of the Earth or other central body."
BurnoutType.LAUNCH_AZIMUTH_ALTITUDE.__doc__ = "Launch Az / Alt - the burnout point is defined in reference to distance downrange along an azimuth, measured from the surface of the Earth or other central body."
BurnoutType.CBF_CARTESIAN.__doc__ = "Central Body Fixed Cartesian - the burnout state is specified in the central-body-fixed Cartesian coordinate system."

agcls.AgTypeNameMap["BurnoutType"] = BurnoutType

class AscentType(IntEnum):
    """Ascent types for the Launch segment."""

    ELLIPSE_CUBIC_MOTION = 0
    """Ellipse: Cubic Motion - the motion is computed on the basis of given positions and velocities."""
    ELLIPSE_QUARTIC_MOTION = 1
    """Ellipse: Quartic Motion - the motion is computed on the basis of given positions and velocities and initial acceleration."""

AscentType.ELLIPSE_CUBIC_MOTION.__doc__ = "Ellipse: Cubic Motion - the motion is computed on the basis of given positions and velocities."
AscentType.ELLIPSE_QUARTIC_MOTION.__doc__ = "Ellipse: Quartic Motion - the motion is computed on the basis of given positions and velocities and initial acceleration."

agcls.AgTypeNameMap["AscentType"] = AscentType

class LaunchDisplaySystem(IntEnum):
    """Launch location coordinate types for the Launch segment."""

    DISPLAY_SYSTEM_GEODETIC = 0
    """Geocentric (Planetocentric) - the location is measured from the center of mass of the Earth or other central body."""
    DISPLAY_SYSTEM_GEOCENTRIC = 1
    """Geodetic (Planetodetic) - the location is measured along the normal to the surface of an ellipsoid defined with reference to the Earth (or other central body)."""

LaunchDisplaySystem.DISPLAY_SYSTEM_GEODETIC.__doc__ = "Geocentric (Planetocentric) - the location is measured from the center of mass of the Earth or other central body."
LaunchDisplaySystem.DISPLAY_SYSTEM_GEOCENTRIC.__doc__ = "Geodetic (Planetodetic) - the location is measured along the normal to the surface of an ellipsoid defined with reference to the Earth (or other central body)."

agcls.AgTypeNameMap["LaunchDisplaySystem"] = LaunchDisplaySystem

class RunCode(IntEnum):
    """The run code returned after the MCS is run."""

    MARCHING = 0
    """Marching - a segment has run successfully."""
    PROFILE_FAILURE = 1
    """Profile Failure - a search profile failed to converge."""
    ERROR = 2
    """Error - encountered an error."""
    STOPPED = 3
    """Stopped - encountered a stop segment."""
    RETURNED = 4
    """Returned - encountered a return segment."""
    CANCELLED = 5
    """Cancelled - cancelled by user."""
    HIT_GLOBAL_STOP = 6
    """Global Stop - hit a global stopping condition."""

RunCode.MARCHING.__doc__ = "Marching - a segment has run successfully."
RunCode.PROFILE_FAILURE.__doc__ = "Profile Failure - a search profile failed to converge."
RunCode.ERROR.__doc__ = "Error - encountered an error."
RunCode.STOPPED.__doc__ = "Stopped - encountered a stop segment."
RunCode.RETURNED.__doc__ = "Returned - encountered a return segment."
RunCode.CANCELLED.__doc__ = "Cancelled - cancelled by user."
RunCode.HIT_GLOBAL_STOP.__doc__ = "Global Stop - hit a global stopping condition."

agcls.AgTypeNameMap["RunCode"] = RunCode

class SequenceStateToPass(IntEnum):
    """State To Pass options for the Sequence segment."""

    INITIAL = 0
    """The initial state of the sequence."""
    FINAL = 1
    """The final state of the sequence."""

SequenceStateToPass.INITIAL.__doc__ = "The initial state of the sequence."
SequenceStateToPass.FINAL.__doc__ = "The final state of the sequence."

agcls.AgTypeNameMap["SequenceStateToPass"] = SequenceStateToPass

class ManeuverType(IntEnum):
    """Maneuver types for the maneuver segment."""

    IMPULSIVE = 0
    """Impulsive - calculates a state by adding the defined delta-V vector to the velocity of the final state of the previous segment, adds this new state to the ephemeris, and passes it to the next segment."""
    FINITE = 1
    """Finite - effectively a Propagate segment with thrust. Like Propagate segments, each point calculated by the propagator is added to the ephemeris, and propagation continues until a stopping condition is met."""
    OPTIMAL_FINITE = 2
    """Optimal Finite."""

ManeuverType.IMPULSIVE.__doc__ = "Impulsive - calculates a state by adding the defined delta-V vector to the velocity of the final state of the previous segment, adds this new state to the ephemeris, and passes it to the next segment."
ManeuverType.FINITE.__doc__ = "Finite - effectively a Propagate segment with thrust. Like Propagate segments, each point calculated by the propagator is added to the ephemeris, and propagation continues until a stopping condition is met."
ManeuverType.OPTIMAL_FINITE.__doc__ = "Optimal Finite."

agcls.AgTypeNameMap["ManeuverType"] = ManeuverType

class SegmentType(IntEnum):
    """Segment types."""

    INITIAL_STATE = 0
    """Initial State - can be used to define the initial conditions of your MCS, or of a subsequence within the MCS."""
    LAUNCH = 1
    """Launch - can be used to model a simple spacecraft launch from Earth or another central body."""
    MANEUVER = 2
    """Maneuver - can be used to model a spacecraft maneuver."""
    FOLLOW = 3
    """Follow - can be used to set the spacecraft to follow another vehicle (Satellite, Launch Vehicle, Missile, Aircraft, Ship, or Ground Vehicle) at a specified offset, and to separate from that vehicle upon meeting specified conditions."""
    HOLD = 4
    """Hold - can be used to model landing or rendezvous operations by setting the spacecraft to maintain a fixed position in reference to another object or body, until meeting specified conditions."""
    PROPAGATE = 5
    """Propagate - can be used to model the movement of the spacecraft along its current trajectory until meeting specified stopping conditions."""
    SEQUENCE = 6
    """Sequence - can be used to organize segments and define the nature of the results that are passed on to the next segment or sequence in the MCS."""
    RETURN = 7
    """Return - can be used to control the execution of the Mission Control Sequence by returning control to its parent segment."""
    TARGET_SEQUENCE = 8
    """Target Sequence - can be used to define maneuvers and propagations in terms of the goals they are intended to achieve."""
    STOP = 9
    """Stop - can be used to control the execution of the Mission Control Sequence by halting execution of the MCS."""
    UPDATE = 10
    """Update - can be used to modify some of the satellite properties to reflect changes that occur during the mission."""
    BACKWARD_SEQUENCE = 11
    """Backward Sequence - can be used to organize segments and define the nature of the results that are passed on to the next segment or sequence in the MCS."""
    END = 12
    """End - The End segment is a default segment of the MCS that functions similarly to a Return segment; it returns control to the beginning of the MCS. The End segment cannot be disabled or deleted, nor can any segments be inserted into the MCS after it."""

SegmentType.INITIAL_STATE.__doc__ = "Initial State - can be used to define the initial conditions of your MCS, or of a subsequence within the MCS."
SegmentType.LAUNCH.__doc__ = "Launch - can be used to model a simple spacecraft launch from Earth or another central body."
SegmentType.MANEUVER.__doc__ = "Maneuver - can be used to model a spacecraft maneuver."
SegmentType.FOLLOW.__doc__ = "Follow - can be used to set the spacecraft to follow another vehicle (Satellite, Launch Vehicle, Missile, Aircraft, Ship, or Ground Vehicle) at a specified offset, and to separate from that vehicle upon meeting specified conditions."
SegmentType.HOLD.__doc__ = "Hold - can be used to model landing or rendezvous operations by setting the spacecraft to maintain a fixed position in reference to another object or body, until meeting specified conditions."
SegmentType.PROPAGATE.__doc__ = "Propagate - can be used to model the movement of the spacecraft along its current trajectory until meeting specified stopping conditions."
SegmentType.SEQUENCE.__doc__ = "Sequence - can be used to organize segments and define the nature of the results that are passed on to the next segment or sequence in the MCS."
SegmentType.RETURN.__doc__ = "Return - can be used to control the execution of the Mission Control Sequence by returning control to its parent segment."
SegmentType.TARGET_SEQUENCE.__doc__ = "Target Sequence - can be used to define maneuvers and propagations in terms of the goals they are intended to achieve."
SegmentType.STOP.__doc__ = "Stop - can be used to control the execution of the Mission Control Sequence by halting execution of the MCS."
SegmentType.UPDATE.__doc__ = "Update - can be used to modify some of the satellite properties to reflect changes that occur during the mission."
SegmentType.BACKWARD_SEQUENCE.__doc__ = "Backward Sequence - can be used to organize segments and define the nature of the results that are passed on to the next segment or sequence in the MCS."
SegmentType.END.__doc__ = "End - The End segment is a default segment of the MCS that functions similarly to a Return segment; it returns control to the beginning of the MCS. The End segment cannot be disabled or deleted, nor can any segments be inserted into the MCS after it."

agcls.AgTypeNameMap["SegmentType"] = SegmentType

class ElementSetType(IntEnum):
    """Types of orbit element sets."""

    CARTESIAN = 0
    """Cartesian - specifying an orbit by three position elements and three velocity elements in a rectangular coordinate system."""
    KEPLERIAN = 1
    """Keplerian - the classical system, specifying an orbit by six elements describing its size, shape and three-dimensional orientation in space."""
    SPHERICAL = 3
    """Spherical - a system in which positions are specified as a radial distance from the origin and two angles relative to a fundamental plane."""
    TARGET_VECTOR_INCOMING_ASYMPTOTE = 4
    """Target Vector Incoming Asymptote - used for hyperbolic arrival trajectories."""
    TARGET_VECTOR_OUTGOING_ASYMPTOTE = 5
    """Target Vector Outgoing Asymptote - used for hyperbolic departure trajectories."""
    MIXED_SPHERICAL = 6
    """Mixed Spherical."""
    DELAUNAY = 7
    """Delaunay."""
    EQUINOCTIAL = 8
    """Equinoctial."""
    GEODETIC = 9
    """Geodetic."""
    B_PLANE = 10
    """BPlane."""
    SPHERICAL_RANGE_RATE = 11
    """Spherical Range Rate."""

ElementSetType.CARTESIAN.__doc__ = "Cartesian - specifying an orbit by three position elements and three velocity elements in a rectangular coordinate system."
ElementSetType.KEPLERIAN.__doc__ = "Keplerian - the classical system, specifying an orbit by six elements describing its size, shape and three-dimensional orientation in space."
ElementSetType.SPHERICAL.__doc__ = "Spherical - a system in which positions are specified as a radial distance from the origin and two angles relative to a fundamental plane."
ElementSetType.TARGET_VECTOR_INCOMING_ASYMPTOTE.__doc__ = "Target Vector Incoming Asymptote - used for hyperbolic arrival trajectories."
ElementSetType.TARGET_VECTOR_OUTGOING_ASYMPTOTE.__doc__ = "Target Vector Outgoing Asymptote - used for hyperbolic departure trajectories."
ElementSetType.MIXED_SPHERICAL.__doc__ = "Mixed Spherical."
ElementSetType.DELAUNAY.__doc__ = "Delaunay."
ElementSetType.EQUINOCTIAL.__doc__ = "Equinoctial."
ElementSetType.GEODETIC.__doc__ = "Geodetic."
ElementSetType.B_PLANE.__doc__ = "BPlane."
ElementSetType.SPHERICAL_RANGE_RATE.__doc__ = "Spherical Range Rate."

agcls.AgTypeNameMap["ElementSetType"] = ElementSetType

class Language(IntEnum):
    """Scripting language types for the Scripting Tool."""

    VB_SCRIPT = 0
    """VBScript."""
    J_SCRIPT = 1
    """JScript."""
    MATLAB = 2
    """MATLAB."""

Language.VB_SCRIPT.__doc__ = "VBScript."
Language.J_SCRIPT.__doc__ = "JScript."
Language.MATLAB.__doc__ = "MATLAB."

agcls.AgTypeNameMap["Language"] = Language

class StoppingConditionType(IntEnum):
    """Type of stopping condition."""

    BASIC = 0
    """Basic Stopping Condition."""
    BEFORE = 1
    """Before Stopping Condition."""
    ONE_POINT_ACCESS = 2
    """One Point Access Stopping Condition."""
    LIGHTING = 3
    """Lighting Stopping Condition."""

StoppingConditionType.BASIC.__doc__ = "Basic Stopping Condition."
StoppingConditionType.BEFORE.__doc__ = "Before Stopping Condition."
StoppingConditionType.ONE_POINT_ACCESS.__doc__ = "One Point Access Stopping Condition."
StoppingConditionType.LIGHTING.__doc__ = "Lighting Stopping Condition."

agcls.AgTypeNameMap["StoppingConditionType"] = StoppingConditionType

class ClearEphemerisDirection(IntEnum):
    """Direction in which to clear ephemeris."""

    BEFORE = -1
    """Clear ephemeris before selected time or state."""
    NO_CLEAR = 0
    """Do not clear ephemeris."""
    AFTER = 1
    """Clear ephemeris after selected time or state."""

ClearEphemerisDirection.BEFORE.__doc__ = "Clear ephemeris before selected time or state."
ClearEphemerisDirection.NO_CLEAR.__doc__ = "Do not clear ephemeris."
ClearEphemerisDirection.AFTER.__doc__ = "Clear ephemeris after selected time or state."

agcls.AgTypeNameMap["ClearEphemerisDirection"] = ClearEphemerisDirection

class ProfileInsertDirection(IntEnum):
    """Direction to insert profile."""

    BEFORE = 0
    """Insert profile before reference profile."""
    AFTER = 1
    """Insert profile after reference profile."""

ProfileInsertDirection.BEFORE.__doc__ = "Insert profile before reference profile."
ProfileInsertDirection.AFTER.__doc__ = "Insert profile after reference profile."

agcls.AgTypeNameMap["ProfileInsertDirection"] = ProfileInsertDirection

class RootFindingAlgorithm(IntEnum):
    """Root-finding algorithms."""

    SECANT_METHOD = 0
    """Secant method."""
    NEWTON_RAPHSON_METHOD = 1
    """Newton-Raphson method."""

RootFindingAlgorithm.SECANT_METHOD.__doc__ = "Secant method."
RootFindingAlgorithm.NEWTON_RAPHSON_METHOD.__doc__ = "Newton-Raphson method."

agcls.AgTypeNameMap["RootFindingAlgorithm"] = RootFindingAlgorithm

class ScriptingParameterType(IntEnum):
    """Scripting Tool parameter type."""

    DOUBLE = 0
    """Double."""
    QUANTITY = 1
    """Quantity."""
    DATE = 2
    """Date."""
    STRING = 3
    """String."""
    BOOLEAN = 4
    """Boolean."""
    INTEGER = 5
    """Integer."""
    ENUMERATION = 6
    """Enumeration."""

ScriptingParameterType.DOUBLE.__doc__ = "Double."
ScriptingParameterType.QUANTITY.__doc__ = "Quantity."
ScriptingParameterType.DATE.__doc__ = "Date."
ScriptingParameterType.STRING.__doc__ = "String."
ScriptingParameterType.BOOLEAN.__doc__ = "Boolean."
ScriptingParameterType.INTEGER.__doc__ = "Integer."
ScriptingParameterType.ENUMERATION.__doc__ = "Enumeration."

agcls.AgTypeNameMap["ScriptingParameterType"] = ScriptingParameterType

class SNOPTGoal(IntEnum):
    """The Goal types for a SNOPT profile."""

    MINIMIZE = 0
    """Minimize."""
    BOUND = 1
    """Bound."""

SNOPTGoal.MINIMIZE.__doc__ = "Minimize."
SNOPTGoal.BOUND.__doc__ = "Bound."

agcls.AgTypeNameMap["SNOPTGoal"] = SNOPTGoal

class IPOPTGoal(IntEnum):
    """The Goal types for a IPOPT profile."""

    MINIMIZE = 0
    """Minimize."""
    BOUND = 1
    """Bound."""

IPOPTGoal.MINIMIZE.__doc__ = "Minimize."
IPOPTGoal.BOUND.__doc__ = "Bound."

agcls.AgTypeNameMap["IPOPTGoal"] = IPOPTGoal

class OptimalFiniteSeedMethod(IntEnum):
    """Seed methods."""

    INITIAL_GUESS_FILE = 0
    """Seed initial guess from file."""
    FINITE_MANEUVER = 1
    """Seed initial guess from finite maneuver."""

OptimalFiniteSeedMethod.INITIAL_GUESS_FILE.__doc__ = "Seed initial guess from file."
OptimalFiniteSeedMethod.FINITE_MANEUVER.__doc__ = "Seed initial guess from finite maneuver."

agcls.AgTypeNameMap["OptimalFiniteSeedMethod"] = OptimalFiniteSeedMethod

class OptimalFiniteRunMode(IntEnum):
    """Run modes."""

    RUN_CURRENT_NODES = 0
    """Run current nodes."""
    OPTIMIZE_VIA_DIRECT_TRANSCRIPTION = 1
    """Optimize via direct transcription."""

OptimalFiniteRunMode.RUN_CURRENT_NODES.__doc__ = "Run current nodes."
OptimalFiniteRunMode.OPTIMIZE_VIA_DIRECT_TRANSCRIPTION.__doc__ = "Optimize via direct transcription."

agcls.AgTypeNameMap["OptimalFiniteRunMode"] = OptimalFiniteRunMode

class OptimalFiniteDiscretizationStrategy(IntEnum):
    """Discretization Strategy."""

    LEGENDRE_GAUSS_LOBATTO = 0
    """The Legendre-Gauss-Lobatto quadrature rule."""
    LEGENDRE_GAUSS_RADAU = 1
    """The Legendre-Gauss-Radau quadrature rule."""

OptimalFiniteDiscretizationStrategy.LEGENDRE_GAUSS_LOBATTO.__doc__ = "The Legendre-Gauss-Lobatto quadrature rule."
OptimalFiniteDiscretizationStrategy.LEGENDRE_GAUSS_RADAU.__doc__ = "The Legendre-Gauss-Radau quadrature rule."

agcls.AgTypeNameMap["OptimalFiniteDiscretizationStrategy"] = OptimalFiniteDiscretizationStrategy

class OptimalFiniteWorkingVariables(IntEnum):
    """Working Variables."""

    EQUINOCTIAL = 0
    """Standard inertial equinoctial coordinates."""
    MODIFIED_EQUINOCTIAL = 1
    """Use semi-latus rectum instead of SMA and true longitude instead of mean longitude."""

OptimalFiniteWorkingVariables.EQUINOCTIAL.__doc__ = "Standard inertial equinoctial coordinates."
OptimalFiniteWorkingVariables.MODIFIED_EQUINOCTIAL.__doc__ = "Use semi-latus rectum instead of SMA and true longitude instead of mean longitude."

agcls.AgTypeNameMap["OptimalFiniteWorkingVariables"] = OptimalFiniteWorkingVariables

class OptimalFiniteScalingOptions(IntEnum):
    """Scaling Options."""

    NO_SCALING = 0
    """No scaling."""
    CANONICAL_UNITS = 1
    """Scale based on canonical units."""
    INITIAL_STATE_BASED = 2
    """Scale based on the initial state."""

OptimalFiniteScalingOptions.NO_SCALING.__doc__ = "No scaling."
OptimalFiniteScalingOptions.CANONICAL_UNITS.__doc__ = "Scale based on canonical units."
OptimalFiniteScalingOptions.INITIAL_STATE_BASED.__doc__ = "Scale based on the initial state."

agcls.AgTypeNameMap["OptimalFiniteScalingOptions"] = OptimalFiniteScalingOptions

class OptimalFiniteSNOPTObjective(IntEnum):
    """Optimal Finite SNOPT objective."""

    MINIMIZE_TIME_OF_FLIGHT = 0
    """Minimize the total TOF along the collocation arc."""
    MAXIMIZE_FINAL_RAD = 1
    """Minimize the total calculated DeltaV along the collocation arc."""
    MINIMIZE_PROPELLANT_USE = 2
    """Maximize the final mass after the collocation arc."""

OptimalFiniteSNOPTObjective.MINIMIZE_TIME_OF_FLIGHT.__doc__ = "Minimize the total TOF along the collocation arc."
OptimalFiniteSNOPTObjective.MAXIMIZE_FINAL_RAD.__doc__ = "Minimize the total calculated DeltaV along the collocation arc."
OptimalFiniteSNOPTObjective.MINIMIZE_PROPELLANT_USE.__doc__ = "Maximize the final mass after the collocation arc."

agcls.AgTypeNameMap["OptimalFiniteSNOPTObjective"] = OptimalFiniteSNOPTObjective

class OptimalFiniteSNOPTScaling(IntEnum):
    """Optimal Finite SNOPT scaling option."""

    NONE = 0
    """No scaling."""
    LINEAR = 1
    """Scale linear constraints and variables."""
    ALL = 2
    """Scale all constraints and variables."""

OptimalFiniteSNOPTScaling.NONE.__doc__ = "No scaling."
OptimalFiniteSNOPTScaling.LINEAR.__doc__ = "Scale linear constraints and variables."
OptimalFiniteSNOPTScaling.ALL.__doc__ = "Scale all constraints and variables."

agcls.AgTypeNameMap["OptimalFiniteSNOPTScaling"] = OptimalFiniteSNOPTScaling

class OptimalFiniteExportNodesFormat(IntEnum):
    """Steering nodes export format."""

    AZIMUTH_ELEVATION = 0
    """Export controls as Az/El = Ra/Dec angles."""
    UNIT_VECTOR = 1
    """Export controls as unit vectors = direction cosines."""

OptimalFiniteExportNodesFormat.AZIMUTH_ELEVATION.__doc__ = "Export controls as Az/El = Ra/Dec angles."
OptimalFiniteExportNodesFormat.UNIT_VECTOR.__doc__ = "Export controls as unit vectors = direction cosines."

agcls.AgTypeNameMap["OptimalFiniteExportNodesFormat"] = OptimalFiniteExportNodesFormat

class OptimalFiniteGuessMethod(IntEnum):
    """Guess interpolation method."""

    LAGRANGE_POLYNOMIAL = 0
    """Lagrange polynomial method."""
    PIECEWISE_LINEAR = 1
    """Piecewise linear method."""

OptimalFiniteGuessMethod.LAGRANGE_POLYNOMIAL.__doc__ = "Lagrange polynomial method."
OptimalFiniteGuessMethod.PIECEWISE_LINEAR.__doc__ = "Piecewise linear method."

agcls.AgTypeNameMap["OptimalFiniteGuessMethod"] = OptimalFiniteGuessMethod

class ImpulsiveDeltaVRepresentation(IntEnum):
    """Vector representations for impulsive DeltaV specification."""

    CARTESIAN_IMPULSIVE_DELTA_V = 0
    """Cartesian - specify the impulsive DeltaV in Cartesian coordinates (X, Y, Z)."""
    SPHERICAL_IMPULSIVE_DELTA_V = 1
    """Spherical - specify the impulsive DeltaV in spherical coordinates (Azimuth, Elevation, Magnitude)."""

ImpulsiveDeltaVRepresentation.CARTESIAN_IMPULSIVE_DELTA_V.__doc__ = "Cartesian - specify the impulsive DeltaV in Cartesian coordinates (X, Y, Z)."
ImpulsiveDeltaVRepresentation.SPHERICAL_IMPULSIVE_DELTA_V.__doc__ = "Spherical - specify the impulsive DeltaV in spherical coordinates (Azimuth, Elevation, Magnitude)."

agcls.AgTypeNameMap["ImpulsiveDeltaVRepresentation"] = ImpulsiveDeltaVRepresentation

class LambertTargetCoordinateType(IntEnum):
    """Lambert Target CoordType."""

    CARTESIAN = 0
    """Cartesian - specifying an orbit by three position elements and three velocity elements in a rectangular coordinate system."""
    KEPLERIAN = 1
    """Keplerian - the classical system, specifying an orbit by six elements describing its size, shape and three-dimensional orientation in space."""

LambertTargetCoordinateType.CARTESIAN.__doc__ = "Cartesian - specifying an orbit by three position elements and three velocity elements in a rectangular coordinate system."
LambertTargetCoordinateType.KEPLERIAN.__doc__ = "Keplerian - the classical system, specifying an orbit by six elements describing its size, shape and three-dimensional orientation in space."

agcls.AgTypeNameMap["LambertTargetCoordinateType"] = LambertTargetCoordinateType

class LambertSolutionOptionType(IntEnum):
    """Lambert Solution Option Type."""

    FIXED_TIME = 0
    """Fixed time - The type of Lambert solution to calculate."""
    MIN_ECCENTRICITY = 1
    """Minimum Eccentricity - The type of Lambert solution to calculate."""
    MIN_ENERGY = 2
    """Minimum Energy - The type of Lambert solution to calculate."""

LambertSolutionOptionType.FIXED_TIME.__doc__ = "Fixed time - The type of Lambert solution to calculate."
LambertSolutionOptionType.MIN_ECCENTRICITY.__doc__ = "Minimum Eccentricity - The type of Lambert solution to calculate."
LambertSolutionOptionType.MIN_ENERGY.__doc__ = "Minimum Energy - The type of Lambert solution to calculate."

agcls.AgTypeNameMap["LambertSolutionOptionType"] = LambertSolutionOptionType

class LambertOrbitalEnergyType(IntEnum):
    """Lambert Orbital Energy Type."""

    LOW = 0
    """Low energy- This is the orbital energy for the Lambert solution that corresponds to the smaller semimajor axis solution."""
    HIGH = 1
    """High energy- This is the orbital energy for the Lambert solution that corresponds to the larger semimajor axis solution."""

LambertOrbitalEnergyType.LOW.__doc__ = "Low energy- This is the orbital energy for the Lambert solution that corresponds to the smaller semimajor axis solution."
LambertOrbitalEnergyType.HIGH.__doc__ = "High energy- This is the orbital energy for the Lambert solution that corresponds to the larger semimajor axis solution."

agcls.AgTypeNameMap["LambertOrbitalEnergyType"] = LambertOrbitalEnergyType

class LambertDirectionOfMotionType(IntEnum):
    """Lambert Direction Of Motion Type."""

    SHORT = 0
    """The short direction of motion for the Lambert solution."""
    LONG = 1
    """The long direction of motion for the Lambert solution."""

LambertDirectionOfMotionType.SHORT.__doc__ = "The short direction of motion for the Lambert solution."
LambertDirectionOfMotionType.LONG.__doc__ = "The long direction of motion for the Lambert solution."

agcls.AgTypeNameMap["LambertDirectionOfMotionType"] = LambertDirectionOfMotionType

class GoldenSectionDesiredOperation(IntEnum):
    """The types for Desired Operation/Objective of golden section profile."""

    MINIMIZE_VALUE = 0
    """Minimize value."""
    MAXIMIZE_VALUE = 1
    """Maximize value."""

GoldenSectionDesiredOperation.MINIMIZE_VALUE.__doc__ = "Minimize value."
GoldenSectionDesiredOperation.MAXIMIZE_VALUE.__doc__ = "Maximize value."

agcls.AgTypeNameMap["GoldenSectionDesiredOperation"] = GoldenSectionDesiredOperation

class GridSearchDesiredOperation(IntEnum):
    """The types for Desired Operation/Objective of Grid Search profile."""

    MINIMIZE_VALUE = 0
    """Minimize value."""
    MAXIMIZE_VALUE = 1
    """Maximize value."""

GridSearchDesiredOperation.MINIMIZE_VALUE.__doc__ = "Minimize value."
GridSearchDesiredOperation.MAXIMIZE_VALUE.__doc__ = "Maximize value."

agcls.AgTypeNameMap["GridSearchDesiredOperation"] = GridSearchDesiredOperation

class ElementType(IntEnum):
    """Which type of elements (osculating or mean)."""

    OSCULATING = 0
    """Osculating."""
    KOZAI_IZSAK_MEAN = 1
    """Kozai-Izsak Mean."""
    BROUWER_LYDDANE_MEAN_LONG = 2
    """Brouwer-Lyddane Mean Long."""
    BROUWER_LYDDANE_MEAN_SHORT = 3
    """Brouwer-Lyddane Mean Short."""

ElementType.OSCULATING.__doc__ = "Osculating."
ElementType.KOZAI_IZSAK_MEAN.__doc__ = "Kozai-Izsak Mean."
ElementType.BROUWER_LYDDANE_MEAN_LONG.__doc__ = "Brouwer-Lyddane Mean Long."
ElementType.BROUWER_LYDDANE_MEAN_SHORT.__doc__ = "Brouwer-Lyddane Mean Short."

agcls.AgTypeNameMap["ElementType"] = ElementType

class BaseSelection(IntEnum):
    """Access base object selections types."""

    SPECIFY = 0
    """An object in the current scenario."""
    CURRENT_SATELLITE = 1
    """The current satellite."""

BaseSelection.SPECIFY.__doc__ = "An object in the current scenario."
BaseSelection.CURRENT_SATELLITE.__doc__ = "The current satellite."

agcls.AgTypeNameMap["BaseSelection"] = BaseSelection

class ControlOrbitStateValue(IntEnum):
    """Orbit State Value properties that can be selected as control parameters for a Target Sequence."""

    VX = 0
    """The Vx velocity component of the orbit state."""
    VY = 1
    """The Vy velocity component of the orbit state."""
    VZ = 2
    """The Vz velocity component of the orbit state."""
    X = 3
    """The x position component of the orbit state."""
    Y = 4
    """The y position component of the orbit state."""
    Z = 5
    """The z position component of the orbit state."""

ControlOrbitStateValue.VX.__doc__ = "The Vx velocity component of the orbit state."
ControlOrbitStateValue.VY.__doc__ = "The Vy velocity component of the orbit state."
ControlOrbitStateValue.VZ.__doc__ = "The Vz velocity component of the orbit state."
ControlOrbitStateValue.X.__doc__ = "The x position component of the orbit state."
ControlOrbitStateValue.Y.__doc__ = "The y position component of the orbit state."
ControlOrbitStateValue.Z.__doc__ = "The z position component of the orbit state."

agcls.AgTypeNameMap["ControlOrbitStateValue"] = ControlOrbitStateValue

class SegmentState(IntEnum):
    """Segment state to use types."""

    INITIAL = 0
    """The segment initial state."""
    FINAL = 1
    """The segment final state."""

SegmentState.INITIAL.__doc__ = "The segment initial state."
SegmentState.FINAL.__doc__ = "The segment final state."

agcls.AgTypeNameMap["SegmentState"] = SegmentState

class DifferenceOrder(IntEnum):
    """The Difference order types."""

    INITIAL_MINUS_CURRENT = 0
    """The initial minus current difference."""
    CURRENT_MINUS_INITIAL = 1
    """The current minus initial difference."""

DifferenceOrder.INITIAL_MINUS_CURRENT.__doc__ = "The initial minus current difference."
DifferenceOrder.CURRENT_MINUS_INITIAL.__doc__ = "The current minus initial difference."

agcls.AgTypeNameMap["DifferenceOrder"] = DifferenceOrder

class SegmentDifferenceOrder(IntEnum):
    """The Difference Across Segments order types."""

    CURRENT_MINUS_SEGMENT = 0
    """The current minus segment difference."""
    SEGMENT_MINUS_CURRENT = 1
    """The segment minus current difference."""

SegmentDifferenceOrder.CURRENT_MINUS_SEGMENT.__doc__ = "The current minus segment difference."
SegmentDifferenceOrder.SEGMENT_MINUS_CURRENT.__doc__ = "The segment minus current difference."

agcls.AgTypeNameMap["SegmentDifferenceOrder"] = SegmentDifferenceOrder

class ControlRepeatingGroundTrackErr(IntEnum):
    """Repeating Ground Track Equator Error properties that can be selected as control parameters for a Target Sequence."""

    REFERENCE_LONGITUDE = 0
    """The reference longitude."""
    REPEAT_COUNT = 1
    """The repeat count."""

ControlRepeatingGroundTrackErr.REFERENCE_LONGITUDE.__doc__ = "The reference longitude."
ControlRepeatingGroundTrackErr.REPEAT_COUNT.__doc__ = "The repeat count."

agcls.AgTypeNameMap["ControlRepeatingGroundTrackErr"] = ControlRepeatingGroundTrackErr

class CalculationObjectDirection(IntEnum):
    """The direction to search for a desired value."""

    NEXT = 0
    """Search in the direction of the next calculation object."""
    PREVIOUS = 1
    """Search in the direction of the previous calculation object."""

CalculationObjectDirection.NEXT.__doc__ = "Search in the direction of the next calculation object."
CalculationObjectDirection.PREVIOUS.__doc__ = "Search in the direction of the previous calculation object."

agcls.AgTypeNameMap["CalculationObjectDirection"] = CalculationObjectDirection

class CalculationObjectOrbitPlaneSource(IntEnum):
    """The calculation object orbit plane source Types."""

    REFERENCE_SATELLITE = 0
    """Use the reference satellite to generate the orbit plane."""
    SATELLITE = 1
    """Use the satellite to generate the orbit plane."""

CalculationObjectOrbitPlaneSource.REFERENCE_SATELLITE.__doc__ = "Use the reference satellite to generate the orbit plane."
CalculationObjectOrbitPlaneSource.SATELLITE.__doc__ = "Use the satellite to generate the orbit plane."

agcls.AgTypeNameMap["CalculationObjectOrbitPlaneSource"] = CalculationObjectOrbitPlaneSource

class CalculationObjectSunPosition(IntEnum):
    """The calculation object sun location Types."""

    APPARENT_FROM_SATELLITE = 0
    """Use the sun location apparent from satellite."""
    APPARENT_FROM_REFERENCE_SATELLITE = 1
    """Use the sun location apparent from reference satellite."""
    TRUE_FROM_SATELLITE = 2
    """Use the sun location true from satellite."""
    TRUE_FROM_REFERENCE_SATELLITE = 3
    """Use the sun location true from reference satellite."""

CalculationObjectSunPosition.APPARENT_FROM_SATELLITE.__doc__ = "Use the sun location apparent from satellite."
CalculationObjectSunPosition.APPARENT_FROM_REFERENCE_SATELLITE.__doc__ = "Use the sun location apparent from reference satellite."
CalculationObjectSunPosition.TRUE_FROM_SATELLITE.__doc__ = "Use the sun location true from satellite."
CalculationObjectSunPosition.TRUE_FROM_REFERENCE_SATELLITE.__doc__ = "Use the sun location true from reference satellite."

agcls.AgTypeNameMap["CalculationObjectSunPosition"] = CalculationObjectSunPosition

class CalculationObjectAngleSign(IntEnum):
    """The sign of the angle when the relative position has a component along the orbit normal."""

    POSITIVE = 0
    """Use the positive sign for the angle when the relative position has a positive component along the orbit normal."""
    NEGATIVE = 1
    """Use the negative sign for the angle when the relative position does not have a positive component along the orbit normal."""

CalculationObjectAngleSign.POSITIVE.__doc__ = "Use the positive sign for the angle when the relative position has a positive component along the orbit normal."
CalculationObjectAngleSign.NEGATIVE.__doc__ = "Use the negative sign for the angle when the relative position does not have a positive component along the orbit normal."

agcls.AgTypeNameMap["CalculationObjectAngleSign"] = CalculationObjectAngleSign

class CalculationObjectReferenceDirection(IntEnum):
    """Direction that establishes the zero value when projected into the orbit plane."""

    REFERENCE_SATELLITE_POSITION = 0
    """Use the reference satellite position when projected into the orbit plane."""
    SATELLITE_POSITION = 1
    """Use the satellite position when projected into the orbit plane."""
    REFERENCE_SATELLITE_NADIR = 2
    """Use the reference satellite nadir (centric) when projected into the orbit plane."""
    SATELLITE_NADIR = 3
    """Use the satellite nadir (centric) position when projected into the orbit plane."""

CalculationObjectReferenceDirection.REFERENCE_SATELLITE_POSITION.__doc__ = "Use the reference satellite position when projected into the orbit plane."
CalculationObjectReferenceDirection.SATELLITE_POSITION.__doc__ = "Use the satellite position when projected into the orbit plane."
CalculationObjectReferenceDirection.REFERENCE_SATELLITE_NADIR.__doc__ = "Use the reference satellite nadir (centric) when projected into the orbit plane."
CalculationObjectReferenceDirection.SATELLITE_NADIR.__doc__ = "Use the satellite nadir (centric) position when projected into the orbit plane."

agcls.AgTypeNameMap["CalculationObjectReferenceDirection"] = CalculationObjectReferenceDirection

class CalculationObjectRelativePosition(IntEnum):
    """The calculation object relative position Types."""

    SATELLITE_TO_REFERENCE_SATELLITE = 0
    """Use the relative position satellite to reference satellite."""
    REFERENCE_SATELLITE_TO_SATELLITE = 1
    """Use the relative position reference satellite to satellite."""

CalculationObjectRelativePosition.SATELLITE_TO_REFERENCE_SATELLITE.__doc__ = "Use the relative position satellite to reference satellite."
CalculationObjectRelativePosition.REFERENCE_SATELLITE_TO_SATELLITE.__doc__ = "Use the relative position reference satellite to satellite."

agcls.AgTypeNameMap["CalculationObjectRelativePosition"] = CalculationObjectRelativePosition

class CalculationObjectReferenceEllipse(IntEnum):
    """The calculation object reference ellipse Types."""

    REFERENCE_SATELLITE_ORBIT = 0
    """Use the reference satellite orbit."""
    SATELLITE_ORBIT = 1
    """Use the satellite orbit."""

CalculationObjectReferenceEllipse.REFERENCE_SATELLITE_ORBIT.__doc__ = "Use the reference satellite orbit."
CalculationObjectReferenceEllipse.SATELLITE_ORBIT.__doc__ = "Use the satellite orbit."

agcls.AgTypeNameMap["CalculationObjectReferenceEllipse"] = CalculationObjectReferenceEllipse

class CalculationObjectLocationSource(IntEnum):
    """The calculation object location source Types."""

    REFERENCE_SATELLITE = 0
    """Use the reference satellite."""
    SATELLITE = 1
    """Use the satellite."""

CalculationObjectLocationSource.REFERENCE_SATELLITE.__doc__ = "Use the reference satellite."
CalculationObjectLocationSource.SATELLITE.__doc__ = "Use the satellite."

agcls.AgTypeNameMap["CalculationObjectLocationSource"] = CalculationObjectLocationSource

class GravitationalParameterSource(IntEnum):
    """The source of the gravitational parameter for a CStateCalcGravitationalParameter calculation object."""

    CENTRAL_BODY_FILE = 0
    """Cb File."""
    CENTRAL_BODY_FILE_SYSTEM = 1
    """Cb File -  System."""
    DESIGN_EXPLORER_OPTIMIZER_FILE = 2
    """DE File."""
    GRAVITY_FILE = 3
    """Gravity File."""

GravitationalParameterSource.CENTRAL_BODY_FILE.__doc__ = "Cb File."
GravitationalParameterSource.CENTRAL_BODY_FILE_SYSTEM.__doc__ = "Cb File -  System."
GravitationalParameterSource.DESIGN_EXPLORER_OPTIMIZER_FILE.__doc__ = "DE File."
GravitationalParameterSource.GRAVITY_FILE.__doc__ = "Gravity File."

agcls.AgTypeNameMap["GravitationalParameterSource"] = GravitationalParameterSource

class ReferenceRadiusSource(IntEnum):
    """The source of the reference radius for a CStateCalcReferenceRadius calculation object."""

    CENTRAL_BODY_FILE = 0
    """Cb File."""
    GRAVITY_FILE = 1
    """Gravity File."""

ReferenceRadiusSource.CENTRAL_BODY_FILE.__doc__ = "Cb File."
ReferenceRadiusSource.GRAVITY_FILE.__doc__ = "Gravity File."

agcls.AgTypeNameMap["ReferenceRadiusSource"] = ReferenceRadiusSource

class GravityCoefficientNormalizationType(IntEnum):
    """The normalization type for the CStateCalcGravCoeff calculation object."""

    NORMALIZED = 0
    """Normalized."""
    UNNORMALIZED = 1
    """Unnormalized."""

GravityCoefficientNormalizationType.NORMALIZED.__doc__ = "Normalized."
GravityCoefficientNormalizationType.UNNORMALIZED.__doc__ = "Unnormalized."

agcls.AgTypeNameMap["GravityCoefficientNormalizationType"] = GravityCoefficientNormalizationType

class GravityCoefficientType(IntEnum):
    """The coefficient type for the CStateCalcGravCoeff calculation object."""

    ZONAL = 0
    """Zonal."""
    COSINE = 1
    """Cosine."""
    SINE = 2
    """Sine."""

GravityCoefficientType.ZONAL.__doc__ = "Zonal."
GravityCoefficientType.COSINE.__doc__ = "Cosine."
GravityCoefficientType.SINE.__doc__ = "Sine."

agcls.AgTypeNameMap["GravityCoefficientType"] = GravityCoefficientType

class STMPerturbationVariables(IntEnum):
    """The initial and final Cartesian variational variables that describe an STM element."""

    POSITION_X = 0
    """Designates the initial or final variation in the 'x' component of position."""
    POSITION_Y = 1
    """Designates the initial or final variation in the 'y' component of position."""
    POSITION_Z = 2
    """Designates the initial or final variation in the 'z' component of position."""
    VELOCITY_X = 3
    """Designates the initial or final variation in the 'x' component of velocity."""
    VELOCITY_Y = 4
    """Designates the initial or final variation in the 'y' component of velocity."""
    VELOCITY_Z = 5
    """Designates the initial or final variation in the 'z' component of velocity."""

STMPerturbationVariables.POSITION_X.__doc__ = "Designates the initial or final variation in the 'x' component of position."
STMPerturbationVariables.POSITION_Y.__doc__ = "Designates the initial or final variation in the 'y' component of position."
STMPerturbationVariables.POSITION_Z.__doc__ = "Designates the initial or final variation in the 'z' component of position."
STMPerturbationVariables.VELOCITY_X.__doc__ = "Designates the initial or final variation in the 'x' component of velocity."
STMPerturbationVariables.VELOCITY_Y.__doc__ = "Designates the initial or final variation in the 'y' component of velocity."
STMPerturbationVariables.VELOCITY_Z.__doc__ = "Designates the initial or final variation in the 'z' component of velocity."

agcls.AgTypeNameMap["STMPerturbationVariables"] = STMPerturbationVariables

class STMEigenNumber(IntEnum):
    """The number that describes one of the 6 STM Eigenvalues or Eigenvectors."""

    NUMBER1 = 0
    """Designates the first Eigenvalue or Eigenvector."""
    NUMBER2 = 1
    """Designates the second Eigenvalue or Eigenvector."""
    NUMBER3 = 2
    """Designates the third Eigenvalue or Eigenvector."""
    NUMBER4 = 3
    """Designates the fourth Eigenvalue or Eigenvector."""
    NUMBER5 = 4
    """Designates the fifth Eigenvalue or Eigenvector."""
    NUMBER6 = 5
    """Designates the sixth Eigenvalue or Eigenvector."""

STMEigenNumber.NUMBER1.__doc__ = "Designates the first Eigenvalue or Eigenvector."
STMEigenNumber.NUMBER2.__doc__ = "Designates the second Eigenvalue or Eigenvector."
STMEigenNumber.NUMBER3.__doc__ = "Designates the third Eigenvalue or Eigenvector."
STMEigenNumber.NUMBER4.__doc__ = "Designates the fourth Eigenvalue or Eigenvector."
STMEigenNumber.NUMBER5.__doc__ = "Designates the fifth Eigenvalue or Eigenvector."
STMEigenNumber.NUMBER6.__doc__ = "Designates the sixth Eigenvalue or Eigenvector."

agcls.AgTypeNameMap["STMEigenNumber"] = STMEigenNumber

class ComplexNumber(IntEnum):
    """Whether a value represents the real or imaginary portion of a number."""

    REAL = 0
    """Designates the value as the real part."""
    IMAGINARY = 1
    """Designates the value as the imaginary part."""

ComplexNumber.REAL.__doc__ = "Designates the value as the real part."
ComplexNumber.IMAGINARY.__doc__ = "Designates the value as the imaginary part."

agcls.AgTypeNameMap["ComplexNumber"] = ComplexNumber

class SquaredType(IntEnum):
    """Whether to calculate the value as the square of the sum of each component or the sum of the squares."""

    SUM_OF_SQUARES = 0
    """Designates the calculation to be the sum of the squares."""
    SQUARE_OF_SUM = 1
    """Designates the calculation to be the square of the sum."""

SquaredType.SUM_OF_SQUARES.__doc__ = "Designates the calculation to be the sum of the squares."
SquaredType.SQUARE_OF_SUM.__doc__ = "Designates the calculation to be the square of the sum."

agcls.AgTypeNameMap["SquaredType"] = SquaredType

class GeoStationaryDriftRateModel(IntEnum):
    """Gravity models used to compute geostationary drift rate."""

    POINT_MASS = 0
    """Compute drift rate using two-body point mass gravity model."""
    POINT_MASS_PLUS_J2 = 1
    """Compute drift rate using gravity model that includes point mass plus secular effect of J2."""

GeoStationaryDriftRateModel.POINT_MASS.__doc__ = "Compute drift rate using two-body point mass gravity model."
GeoStationaryDriftRateModel.POINT_MASS_PLUS_J2.__doc__ = "Compute drift rate using gravity model that includes point mass plus secular effect of J2."

agcls.AgTypeNameMap["GeoStationaryDriftRateModel"] = GeoStationaryDriftRateModel

class GeoStationaryInclinationMagnitude(IntEnum):
    """Magnitude to use when computing the inclination vector."""

    INCLINATION_ANGLE = 0
    """Compute inclination vector magnitude as the inclination angle itself (in radins)."""
    SIN_INCLINATION = 1
    """Compute inclination vector magnitude as sin(inclination)."""
    SIN_HALF_INCLINATION = 2
    """Compute inclination vector magnitude as sin(0.5*inclination)."""
    TWICE_SIN_HALF_INCLINATION = 3
    """Compute inclination vector magnitude as 2*sin(0.5*inclination)."""
    TAN_HALF_INCLINATION = 4
    """Compute inclination vector magnitude as tan(0.5*inclination)."""
    TWICE_TAN_HALF_INCLINATION = 5
    """Compute inclination vector magnitude as 2*tan(0.5*inclination)."""

GeoStationaryInclinationMagnitude.INCLINATION_ANGLE.__doc__ = "Compute inclination vector magnitude as the inclination angle itself (in radins)."
GeoStationaryInclinationMagnitude.SIN_INCLINATION.__doc__ = "Compute inclination vector magnitude as sin(inclination)."
GeoStationaryInclinationMagnitude.SIN_HALF_INCLINATION.__doc__ = "Compute inclination vector magnitude as sin(0.5*inclination)."
GeoStationaryInclinationMagnitude.TWICE_SIN_HALF_INCLINATION.__doc__ = "Compute inclination vector magnitude as 2*sin(0.5*inclination)."
GeoStationaryInclinationMagnitude.TAN_HALF_INCLINATION.__doc__ = "Compute inclination vector magnitude as tan(0.5*inclination)."
GeoStationaryInclinationMagnitude.TWICE_TAN_HALF_INCLINATION.__doc__ = "Compute inclination vector magnitude as 2*tan(0.5*inclination)."

agcls.AgTypeNameMap["GeoStationaryInclinationMagnitude"] = GeoStationaryInclinationMagnitude

class CentralBodyGravityModel(IntEnum):
    """The gravity model."""

    ZONALS_TO_J4 = 0
    """ZonalsToJ4 - (various) Gravity model for all central bodies except Sun, Earth and Moon."""
    EARTH_SIMPLE = 1
    """Earth Simple gravity model."""
    WGS84 = 2
    """WGS84 - (Earth) World Geodetic System 1984; WGS 84 was created by the Defense Mapping Agency (DMA)."""
    EGM96 = 3
    """EGM96 - (Earth) Earth Gravity Model 1996, a geopotential model of the Earth consisting of spherical harmonic coefficients complete to degree and order 360. Developed jointly by NGA (formerly known as NIMA), NASA Goddard and Ohio State University."""
    GEMT1 = 4
    """GEMT1 - (Earth) Goddard Earth Model T1."""
    JGM2 = 5
    """JGM2 - (Earth) Joint Gravity Model version 2, a model that describes the Earth gravity field up to degree and order 70, developed by NASA/GSFC Space Geodesy Branch, the University of Texas Center for Space Research and CNES."""
    JGM3 = 6
    """JGM3 - (Earth) Joint Gravity Model version 3, a model that describes the Earth gravity field up to degree and order 70, developed by the University of Texas and NASA/GSFC."""
    WSG84EGM96 = 7
    """WGS84 EGM96 - (Earth) Uses the coefficients from EGM96 with the shape model of WGS84. This model is the recommended gravity model of the WGS84 definition document: NIMA TR8350.2, Third Edition, 4 July 1997."""
    WGS84_OLD = 8
    """WGS84 old - (Earth) Old version of WGS84."""
    GLGM2 = 9
    """GLGM2 - (Moon) GM = 4.9028029535968e+12, reference distance = 1,738,000 m."""
    LP165P = 10
    """LP165P - (Moon) GM = 4.902801056E+12, reference distance = 1,738,000.0 m."""
    ICARUS1987 = 11
    """Icarus1987 - (Mercury) GM = 2.203209e+013, reference distance = 2,439,000 m. Reference: Anderson, J. J., Colombo, G., Esposito, P. B., Lau E. L., and Trager, G. B. 'The Mass, Gravity Field, and Ephemeris of Mercury', Icarus 71, 337-349, 1987."""
    MGNP180U = 12
    """MGNP180U - (Venus) GM = 3.248585920790000E+14, reference distance = 6,051,000.0 m."""
    GMM1 = 13
    """GMM1 - (Mars) GM = 4.28283579647735e+13, reference distance = 3,394,200.0 m."""
    GMM2B = 14
    """GMM2B - (Mars) GM = 4.28283719012840e+13, reference distance = 3,397,000 m. Reference: These numbers came from the GMM-2B model published at `NASA <https://www.nasa.gov/>`_ and were gotten from Journal of Geophysical Research, November 2000."""
    MARS50_C = 15
    """Mars50c - (Mars) GM = 4.2828370371000e+13, reference distance = 3,394,200 m."""
    JUP230 = 16
    """JUP230 - (Jupiter) GM = 1.26686535e+017, reference distance = 71,492,000 m. Reference: Jacobson, R. A. The JUP230 orbit solution, 2003."""
    ASTRON2004 = 17
    """Astron2004 - (Saturn) GM = 3.7931284e+016, reference distance = 60,330,000 m."""
    ASTRON_ASTRO1991 = 18
    """AstronAstro1991 - (Neptune) GM = 6.835107e+015, reference distance = 25,225,000 m."""
    ICARUS2001 = 19
    """Icarus2001 - (Callisto) GM = 7.179292e+12, reference distance = 2,410,300 m."""
    SCIENCE1998 = 20
    """Science1998 - (Europa) GM =3.20272e+012, reference distance = 1,565,000 m."""
    NATURE1996 = 21
    """Nature1996 - (Ganymede) GM = 9.8866e+12, reference distance = 2,634,000 m."""
    J_GEO_RES2001 = 22
    """JGeoRes2001 - (Io) GM = 5.96e+12, reference distance = 1,821,600 m."""
    GGM01C = 23
    """GGM01C - (Earth)."""
    GGM02C = 24
    """GGM02C - (Earth)."""
    WGS72_ZONALS_TO_J4 = 25
    """WGS72 ZonalsToJ4 - (Earth)."""
    LP100J = 26
    """LP100J - (Moon)."""
    LP100K = 27
    """LP100K - (Moon)."""
    LP150Q = 28
    """LP150Q - (Moon)."""
    LP75G = 29
    """LP75G - (Moon)."""

CentralBodyGravityModel.ZONALS_TO_J4.__doc__ = "ZonalsToJ4 - (various) Gravity model for all central bodies except Sun, Earth and Moon."
CentralBodyGravityModel.EARTH_SIMPLE.__doc__ = "Earth Simple gravity model."
CentralBodyGravityModel.WGS84.__doc__ = "WGS84 - (Earth) World Geodetic System 1984; WGS 84 was created by the Defense Mapping Agency (DMA)."
CentralBodyGravityModel.EGM96.__doc__ = "EGM96 - (Earth) Earth Gravity Model 1996, a geopotential model of the Earth consisting of spherical harmonic coefficients complete to degree and order 360. Developed jointly by NGA (formerly known as NIMA), NASA Goddard and Ohio State University."
CentralBodyGravityModel.GEMT1.__doc__ = "GEMT1 - (Earth) Goddard Earth Model T1."
CentralBodyGravityModel.JGM2.__doc__ = "JGM2 - (Earth) Joint Gravity Model version 2, a model that describes the Earth gravity field up to degree and order 70, developed by NASA/GSFC Space Geodesy Branch, the University of Texas Center for Space Research and CNES."
CentralBodyGravityModel.JGM3.__doc__ = "JGM3 - (Earth) Joint Gravity Model version 3, a model that describes the Earth gravity field up to degree and order 70, developed by the University of Texas and NASA/GSFC."
CentralBodyGravityModel.WSG84EGM96.__doc__ = "WGS84 EGM96 - (Earth) Uses the coefficients from EGM96 with the shape model of WGS84. This model is the recommended gravity model of the WGS84 definition document: NIMA TR8350.2, Third Edition, 4 July 1997."
CentralBodyGravityModel.WGS84_OLD.__doc__ = "WGS84 old - (Earth) Old version of WGS84."
CentralBodyGravityModel.GLGM2.__doc__ = "GLGM2 - (Moon) GM = 4.9028029535968e+12, reference distance = 1,738,000 m."
CentralBodyGravityModel.LP165P.__doc__ = "LP165P - (Moon) GM = 4.902801056E+12, reference distance = 1,738,000.0 m."
CentralBodyGravityModel.ICARUS1987.__doc__ = "Icarus1987 - (Mercury) GM = 2.203209e+013, reference distance = 2,439,000 m. Reference: Anderson, J. J., Colombo, G., Esposito, P. B., Lau E. L., and Trager, G. B. 'The Mass, Gravity Field, and Ephemeris of Mercury', Icarus 71, 337-349, 1987."
CentralBodyGravityModel.MGNP180U.__doc__ = "MGNP180U - (Venus) GM = 3.248585920790000E+14, reference distance = 6,051,000.0 m."
CentralBodyGravityModel.GMM1.__doc__ = "GMM1 - (Mars) GM = 4.28283579647735e+13, reference distance = 3,394,200.0 m."
CentralBodyGravityModel.GMM2B.__doc__ = "GMM2B - (Mars) GM = 4.28283719012840e+13, reference distance = 3,397,000 m. Reference: These numbers came from the GMM-2B model published at `NASA <https://www.nasa.gov/>`_ and were gotten from Journal of Geophysical Research, November 2000."
CentralBodyGravityModel.MARS50_C.__doc__ = "Mars50c - (Mars) GM = 4.2828370371000e+13, reference distance = 3,394,200 m."
CentralBodyGravityModel.JUP230.__doc__ = "JUP230 - (Jupiter) GM = 1.26686535e+017, reference distance = 71,492,000 m. Reference: Jacobson, R. A. The JUP230 orbit solution, 2003."
CentralBodyGravityModel.ASTRON2004.__doc__ = "Astron2004 - (Saturn) GM = 3.7931284e+016, reference distance = 60,330,000 m."
CentralBodyGravityModel.ASTRON_ASTRO1991.__doc__ = "AstronAstro1991 - (Neptune) GM = 6.835107e+015, reference distance = 25,225,000 m."
CentralBodyGravityModel.ICARUS2001.__doc__ = "Icarus2001 - (Callisto) GM = 7.179292e+12, reference distance = 2,410,300 m."
CentralBodyGravityModel.SCIENCE1998.__doc__ = "Science1998 - (Europa) GM =3.20272e+012, reference distance = 1,565,000 m."
CentralBodyGravityModel.NATURE1996.__doc__ = "Nature1996 - (Ganymede) GM = 9.8866e+12, reference distance = 2,634,000 m."
CentralBodyGravityModel.J_GEO_RES2001.__doc__ = "JGeoRes2001 - (Io) GM = 5.96e+12, reference distance = 1,821,600 m."
CentralBodyGravityModel.GGM01C.__doc__ = "GGM01C - (Earth)."
CentralBodyGravityModel.GGM02C.__doc__ = "GGM02C - (Earth)."
CentralBodyGravityModel.WGS72_ZONALS_TO_J4.__doc__ = "WGS72 ZonalsToJ4 - (Earth)."
CentralBodyGravityModel.LP100J.__doc__ = "LP100J - (Moon)."
CentralBodyGravityModel.LP100K.__doc__ = "LP100K - (Moon)."
CentralBodyGravityModel.LP150Q.__doc__ = "LP150Q - (Moon)."
CentralBodyGravityModel.LP75G.__doc__ = "LP75G - (Moon)."

agcls.AgTypeNameMap["CentralBodyGravityModel"] = CentralBodyGravityModel

class CentralBodyShape(IntEnum):
    """The central body shape types."""

    TRIAXIAL_ELLIPSOID = 0
    """A triaxial ellipsoid defined by a semi-major axis, semi-mid axis and semi-minor axis."""
    OBLATE_SPHEROID = 1
    """An oblate spheroid defined by a minimum and maximum radii, and a derived flattening coefficient."""
    SPHERE = 2
    """A sphere defined by a radius."""

CentralBodyShape.TRIAXIAL_ELLIPSOID.__doc__ = "A triaxial ellipsoid defined by a semi-major axis, semi-mid axis and semi-minor axis."
CentralBodyShape.OBLATE_SPHEROID.__doc__ = "An oblate spheroid defined by a minimum and maximum radii, and a derived flattening coefficient."
CentralBodyShape.SPHERE.__doc__ = "A sphere defined by a radius."

agcls.AgTypeNameMap["CentralBodyShape"] = CentralBodyShape

class CentralBodyAttitude(IntEnum):
    """The central body attitude types."""

    IAU1994 = 0
    """An IAU 1994 attitude definition."""
    ROTATION_COEFFICIENTS_FILE = 1
    """A rotation coefficient file."""

CentralBodyAttitude.IAU1994.__doc__ = "An IAU 1994 attitude definition."
CentralBodyAttitude.ROTATION_COEFFICIENTS_FILE.__doc__ = "A rotation coefficient file."

agcls.AgTypeNameMap["CentralBodyAttitude"] = CentralBodyAttitude

class CentralBodyEphemeris(IntEnum):
    """The central body ephemeris types."""

    ANALYTIC_ORBIT = 0
    """Specified values and rates of change for the classical orbital elements."""
    FILE = 1
    """An external ephemeris (.e) file."""
    JPLDE = 2
    """Ephemerides from the Jet Propulsion Laboratory's JPL DE set are used."""
    JPLSPICE = 3
    """The SPICE propagator reads ephemeris from binary files that are in a standard format produced by the Jet Propulsion Laboratory for ephemeris for celestial bodies but can be used for spacecraft."""
    PLANETARY = 4
    """A planetary ephemeris (.pe) file."""

CentralBodyEphemeris.ANALYTIC_ORBIT.__doc__ = "Specified values and rates of change for the classical orbital elements."
CentralBodyEphemeris.FILE.__doc__ = "An external ephemeris (.e) file."
CentralBodyEphemeris.JPLDE.__doc__ = "Ephemerides from the Jet Propulsion Laboratory's JPL DE set are used."
CentralBodyEphemeris.JPLSPICE.__doc__ = "The SPICE propagator reads ephemeris from binary files that are in a standard format produced by the Jet Propulsion Laboratory for ephemeris for celestial bodies but can be used for spacecraft."
CentralBodyEphemeris.PLANETARY.__doc__ = "A planetary ephemeris (.pe) file."

agcls.AgTypeNameMap["CentralBodyEphemeris"] = CentralBodyEphemeris

class ControlPowerInternal(IntEnum):
    """Internal Power properties that can be selected as control parameters for a Target Sequence."""

    GENERATED_POWER = 0
    """The power generated by the spacecraft from internal sources."""
    PERCENT_DEGRADATION = 1
    """The percent degradation per year; degradation factor is (1 - x%/yr)timeSinceRefEpoch."""
    EPOCH = 2
    """The date and time used as a reference epoch for degradation."""

ControlPowerInternal.GENERATED_POWER.__doc__ = "The power generated by the spacecraft from internal sources."
ControlPowerInternal.PERCENT_DEGRADATION.__doc__ = "The percent degradation per year; degradation factor is (1 - x%/yr)timeSinceRefEpoch."
ControlPowerInternal.EPOCH.__doc__ = "The date and time used as a reference epoch for degradation."

agcls.AgTypeNameMap["ControlPowerInternal"] = ControlPowerInternal

class ControlPowerProcessed(IntEnum):
    """Processed Power properties that can be selected as control parameters for a Target Sequence."""

    EFFICIENCY = 0
    """The efficiency of the power processing unit(PPU)."""
    LOAD = 1
    """The power diverted from the power source and unavailable to the power processing unit(PPU)."""

ControlPowerProcessed.EFFICIENCY.__doc__ = "The efficiency of the power processing unit(PPU)."
ControlPowerProcessed.LOAD.__doc__ = "The power diverted from the power source and unavailable to the power processing unit(PPU)."

agcls.AgTypeNameMap["ControlPowerProcessed"] = ControlPowerProcessed

class ControlPowerSolarArray(IntEnum):
    """Solar Array Power properties that can be selected as control parameters for a Target Sequence."""

    C0 = 0
    """The ThermalModel.C0 coefficient."""
    C1 = 1
    """The ThermalModel.C1 coefficient."""
    C2 = 2
    """The ThermalModel.C2 coefficient."""
    C3 = 3
    """The ThermalModel.C3 coefficient."""
    C4 = 4
    """The ThermalModel.C4 coefficient."""
    AREA = 5
    """The solar array panel area."""
    EFFICIENCY = 6
    """The array efficiency in producing output power from a collection of cells."""
    CELL_EFFICIENCY = 7
    """The cell efficiency in producing output power from incident sunlight."""
    CONCENTRATION = 8
    """The solar array concentration factor."""
    INCLINATION_TO_SUN_LINE = 9
    """The angle from the panel normal vector to the apparent sun line."""
    PERCENT_DEGRADATION = 10
    """The percent degradation per year; degradation factor is (1 - x%/yr)timeSinceRefEpoch."""
    EPOCH = 11
    """The date and time used as a reference epoch for degradation."""

ControlPowerSolarArray.C0.__doc__ = "The ThermalModel.C0 coefficient."
ControlPowerSolarArray.C1.__doc__ = "The ThermalModel.C1 coefficient."
ControlPowerSolarArray.C2.__doc__ = "The ThermalModel.C2 coefficient."
ControlPowerSolarArray.C3.__doc__ = "The ThermalModel.C3 coefficient."
ControlPowerSolarArray.C4.__doc__ = "The ThermalModel.C4 coefficient."
ControlPowerSolarArray.AREA.__doc__ = "The solar array panel area."
ControlPowerSolarArray.EFFICIENCY.__doc__ = "The array efficiency in producing output power from a collection of cells."
ControlPowerSolarArray.CELL_EFFICIENCY.__doc__ = "The cell efficiency in producing output power from incident sunlight."
ControlPowerSolarArray.CONCENTRATION.__doc__ = "The solar array concentration factor."
ControlPowerSolarArray.INCLINATION_TO_SUN_LINE.__doc__ = "The angle from the panel normal vector to the apparent sun line."
ControlPowerSolarArray.PERCENT_DEGRADATION.__doc__ = "The percent degradation per year; degradation factor is (1 - x%/yr)timeSinceRefEpoch."
ControlPowerSolarArray.EPOCH.__doc__ = "The date and time used as a reference epoch for degradation."

agcls.AgTypeNameMap["ControlPowerSolarArray"] = ControlPowerSolarArray

class ThirdBodyMode(IntEnum):
    """The third body gravity mode."""

    GRAVITY_FIELD = 0
    """Define the gravitational effect as a full Gravitational Force model."""
    POINT_MASS = 1
    """Define the gravitational effect as a third body point mass effect."""

ThirdBodyMode.GRAVITY_FIELD.__doc__ = "Define the gravitational effect as a full Gravitational Force model."
ThirdBodyMode.POINT_MASS.__doc__ = "Define the gravitational effect as a third body point mass effect."

agcls.AgTypeNameMap["ThirdBodyMode"] = ThirdBodyMode

class GravParamSource(IntEnum):
    """The gravity parameter source."""

    CENTRAL_BODY_FILE = 0
    """The Cb file provided with STK; uses the default, body centered gravity source for the central body."""
    DESIGN_EXPLORER_OPTIMIZER_FILE = 1
    """A DE file; body centered for the inner planets and barycentered for the outer planets."""
    USER = 2
    """User defined; requires you to specify the mu value of the Gravitational Parameter."""
    CENTRAL_BODY_FILE_SYSTEM = 3
    """The Cb file provided with STK; uses the default, barycentered gravity source for the central body."""

GravParamSource.CENTRAL_BODY_FILE.__doc__ = "The Cb file provided with STK; uses the default, body centered gravity source for the central body."
GravParamSource.DESIGN_EXPLORER_OPTIMIZER_FILE.__doc__ = "A DE file; body centered for the inner planets and barycentered for the outer planets."
GravParamSource.USER.__doc__ = "User defined; requires you to specify the mu value of the Gravitational Parameter."
GravParamSource.CENTRAL_BODY_FILE_SYSTEM.__doc__ = "The Cb file provided with STK; uses the default, barycentered gravity source for the central body."

agcls.AgTypeNameMap["GravParamSource"] = GravParamSource

class EphemerisSource(IntEnum):
    """The ephemeris source type."""

    CENTRAL_BODY_FILE = 0
    """The Cb file provided with STK; uses the default ephemeris source for that central body."""
    DESIGN_EXPLORER_OPTIMIZER_FILE = 1
    """A DE file; body centered for the inner planets and barycentered for the outer planets."""
    SPICE_BARY = 2
    """A SPICE file, barycentered; uses the entire planetary system as a single effect, with the system center as the point mass."""
    SPICE_BODY = 3
    """A SPICE file, body centered; uses only the planet as the effect, with the planet's center as the point mass."""

EphemerisSource.CENTRAL_BODY_FILE.__doc__ = "The Cb file provided with STK; uses the default ephemeris source for that central body."
EphemerisSource.DESIGN_EXPLORER_OPTIMIZER_FILE.__doc__ = "A DE file; body centered for the inner planets and barycentered for the outer planets."
EphemerisSource.SPICE_BARY.__doc__ = "A SPICE file, barycentered; uses the entire planetary system as a single effect, with the system center as the point mass."
EphemerisSource.SPICE_BODY.__doc__ = "A SPICE file, body centered; uses only the planet as the effect, with the planet's center as the point mass."

agcls.AgTypeNameMap["EphemerisSource"] = EphemerisSource

class SolarForceMethod(IntEnum):
    """The solar force method type for a spherical or N-plate SRP model."""

    LUMINOSITY = 0
    """Luminosity - used as the value for solar flux at 1 AU in the Solar Radiation computation."""
    MEAN_FLUX = 1
    """Mean Flux - used as the value for solar flux at 1 AU in the Solar Radiation computation."""

SolarForceMethod.LUMINOSITY.__doc__ = "Luminosity - used as the value for solar flux at 1 AU in the Solar Radiation computation."
SolarForceMethod.MEAN_FLUX.__doc__ = "Mean Flux - used as the value for solar flux at 1 AU in the Solar Radiation computation."

agcls.AgTypeNameMap["SolarForceMethod"] = SolarForceMethod

class ShadowModel(IntEnum):
    """The shadow model type."""

    CYLINDRICAL = 0
    """Cylindrical - assumes the Sun to be at infinite distance so that all light coming from the Sun moves in a direction parallel to the Sun to satellite vector."""
    DUAL_CONE = 1
    """Dual Cone - uses the actual size and distance of the Sun to model regions of full, partial (penumbra) and zero (umbra) sunlight. The visible fraction of the solar disk is used to compute the acceleration during penumbra."""
    NONE = 2
    """None - turns off all shadowing of the satellite."""

ShadowModel.CYLINDRICAL.__doc__ = "Cylindrical - assumes the Sun to be at infinite distance so that all light coming from the Sun moves in a direction parallel to the Sun to satellite vector."
ShadowModel.DUAL_CONE.__doc__ = "Dual Cone - uses the actual size and distance of the Sun to model regions of full, partial (penumbra) and zero (umbra) sunlight. The visible fraction of the solar disk is used to compute the acceleration during penumbra."
ShadowModel.NONE.__doc__ = "None - turns off all shadowing of the satellite."

agcls.AgTypeNameMap["ShadowModel"] = ShadowModel

class SunPosition(IntEnum):
    """The sun position type."""

    APPARENT = 0
    """Apparent - takes into account the time required for light to travel from the sun to the position of the spacecraft."""
    APPARENT_TO_TRUE_CENTRAL_BODY = 1
    """Apparent Sun to True Cb - takes into account the time required for light to travel from the sun to the central body."""
    TRUE = 2
    """True - assumes that light from the sun reaches the spacecraft instantaneously."""

SunPosition.APPARENT.__doc__ = "Apparent - takes into account the time required for light to travel from the sun to the position of the spacecraft."
SunPosition.APPARENT_TO_TRUE_CENTRAL_BODY.__doc__ = "Apparent Sun to True Cb - takes into account the time required for light to travel from the sun to the central body."
SunPosition.TRUE.__doc__ = "True - assumes that light from the sun reaches the spacecraft instantaneously."

agcls.AgTypeNameMap["SunPosition"] = SunPosition

class AtmosphereDataSource(IntEnum):
    """The Atmospheric data source type."""

    CONSTANT = 0
    """Constant Atmospheric data source."""
    FILE = 1
    """Atmopsheric data source from file."""

AtmosphereDataSource.CONSTANT.__doc__ = "Constant Atmospheric data source."
AtmosphereDataSource.FILE.__doc__ = "Atmopsheric data source from file."

agcls.AgTypeNameMap["AtmosphereDataSource"] = AtmosphereDataSource

class GeoMagneticFluxSource(IntEnum):
    """Whether to use Kp or Ap data from the flux file."""

    AP = 0
    """Read Ap from file."""
    KP = 1
    """Read Kp from file."""

GeoMagneticFluxSource.AP.__doc__ = "Read Ap from file."
GeoMagneticFluxSource.KP.__doc__ = "Read Kp from file."

agcls.AgTypeNameMap["GeoMagneticFluxSource"] = GeoMagneticFluxSource

class GeoMagneticFluxUpdateRate(IntEnum):
    """Method for using geomagnetic flux values from the flux file."""

    RATE3_HOURLY = 0
    """Three hourly."""
    RATE3_HOURLY_CUBIC_SPLINE = 1
    """Three hourly cubic spline."""
    RATE3_HOURLY_INTERPOLATED = 2
    """Three hourly interpolated."""
    DAILY = 3
    """Daily."""

GeoMagneticFluxUpdateRate.RATE3_HOURLY.__doc__ = "Three hourly."
GeoMagneticFluxUpdateRate.RATE3_HOURLY_CUBIC_SPLINE.__doc__ = "Three hourly cubic spline."
GeoMagneticFluxUpdateRate.RATE3_HOURLY_INTERPOLATED.__doc__ = "Three hourly interpolated."
GeoMagneticFluxUpdateRate.DAILY.__doc__ = "Daily."

agcls.AgTypeNameMap["GeoMagneticFluxUpdateRate"] = GeoMagneticFluxUpdateRate

class DragModelType(IntEnum):
    """Type of Drag Model."""

    SPHERICAL = 0
    """Spherical."""
    PLUGIN = 1
    """Plugin."""
    VARIABLE_AREA = 2
    """Variable Area."""
    N_PLATE = 3
    """N-Plate."""

DragModelType.SPHERICAL.__doc__ = "Spherical."
DragModelType.PLUGIN.__doc__ = "Plugin."
DragModelType.VARIABLE_AREA.__doc__ = "Variable Area."
DragModelType.N_PLATE.__doc__ = "N-Plate."

agcls.AgTypeNameMap["DragModelType"] = DragModelType

class MarsGRAMDensityType(IntEnum):
    """Density Type for MarsGRAM Density Models."""

    LOW = 0
    """Low density."""
    MEAN = 1
    """Mean density."""
    HIGH = 2
    """High density."""
    RANDOMLY_PERTURBED = 3
    """Randomly perturbed density."""

MarsGRAMDensityType.LOW.__doc__ = "Low density."
MarsGRAMDensityType.MEAN.__doc__ = "Mean density."
MarsGRAMDensityType.HIGH.__doc__ = "High density."
MarsGRAMDensityType.RANDOMLY_PERTURBED.__doc__ = "Randomly perturbed density."

agcls.AgTypeNameMap["MarsGRAMDensityType"] = MarsGRAMDensityType

class VenusGRAMDensityType(IntEnum):
    """Density Type for VenusGRAM Density Models."""

    LOW = 0
    """Low density."""
    MEAN = 1
    """Mean density."""
    HIGH = 2
    """High density."""
    RANDOMLY_PERTURBED = 3
    """Randomly perturbed density."""

VenusGRAMDensityType.LOW.__doc__ = "Low density."
VenusGRAMDensityType.MEAN.__doc__ = "Mean density."
VenusGRAMDensityType.HIGH.__doc__ = "High density."
VenusGRAMDensityType.RANDOMLY_PERTURBED.__doc__ = "Randomly perturbed density."

agcls.AgTypeNameMap["VenusGRAMDensityType"] = VenusGRAMDensityType

class TabVecInterpolationMethod(IntEnum):
    """The interpolation method for tabulated area vector file."""

    CARTESIAN_INTERPOLATION = 0
    """Bilinear interpolation on the Cartesian grid."""
    MAGNITUDE_AND_DIRECTION_INTERPOLATION = 1
    """Bilinear interpolation in magnitude and direction space."""

TabVecInterpolationMethod.CARTESIAN_INTERPOLATION.__doc__ = "Bilinear interpolation on the Cartesian grid."
TabVecInterpolationMethod.MAGNITUDE_AND_DIRECTION_INTERPOLATION.__doc__ = "Bilinear interpolation in magnitude and direction space."

agcls.AgTypeNameMap["TabVecInterpolationMethod"] = TabVecInterpolationMethod

class ControlEngineConstantAcceleration(IntEnum):
    """Constant Acceleration and Isp engine model properties that can be selected as control parameters for a Target Sequence."""

    GRAV = 0
    """The gravitational acceleration constant at sea level on the Earth."""
    ACCELERATION = 1
    """The acceleration for the engine."""
    ISP = 2
    """The specific impulse for the engine."""

ControlEngineConstantAcceleration.GRAV.__doc__ = "The gravitational acceleration constant at sea level on the Earth."
ControlEngineConstantAcceleration.ACCELERATION.__doc__ = "The acceleration for the engine."
ControlEngineConstantAcceleration.ISP.__doc__ = "The specific impulse for the engine."

agcls.AgTypeNameMap["ControlEngineConstantAcceleration"] = ControlEngineConstantAcceleration

class ControlEngineConstant(IntEnum):
    """Constant Thrust and Isp engine model properties that can be selected as control parameters for a Target Sequence."""

    GRAV = 0
    """The gravitational acceleration constant at sea level on the Earth."""
    THRUST = 1
    """The thrust for the engine."""
    ISP = 2
    """The specific impulse for the engine."""

ControlEngineConstant.GRAV.__doc__ = "The gravitational acceleration constant at sea level on the Earth."
ControlEngineConstant.THRUST.__doc__ = "The thrust for the engine."
ControlEngineConstant.ISP.__doc__ = "The specific impulse for the engine."

agcls.AgTypeNameMap["ControlEngineConstant"] = ControlEngineConstant

class ControlEngineCustom(IntEnum):
    """Custom engine model properties that can be selected as control parameters for a Target Sequence."""

    GRAV = 0
    """Earth surface gravity acceleration for Isp conversions."""

ControlEngineCustom.GRAV.__doc__ = "Earth surface gravity acceleration for Isp conversions."

agcls.AgTypeNameMap["ControlEngineCustom"] = ControlEngineCustom

class ControlEngineThrottleTable(IntEnum):
    """Throttle table engine model properties that can be selected as control parameters for a Target Sequence."""

    GRAV = 0
    """Gravitational acceleration constant at sea level on the Earth."""
    PERCENT_DEGRADATION_PER_YEAR = 1
    """The degradation factor is (1 - x)n, where n is the time since epoch in years, and x is the percent degradation per year."""
    REFERENCE_EPOCH = 2
    """The date and time used as a reference epoch for degradation."""

ControlEngineThrottleTable.GRAV.__doc__ = "Gravitational acceleration constant at sea level on the Earth."
ControlEngineThrottleTable.PERCENT_DEGRADATION_PER_YEAR.__doc__ = "The degradation factor is (1 - x)n, where n is the time since epoch in years, and x is the percent degradation per year."
ControlEngineThrottleTable.REFERENCE_EPOCH.__doc__ = "The date and time used as a reference epoch for degradation."

agcls.AgTypeNameMap["ControlEngineThrottleTable"] = ControlEngineThrottleTable

class ControlEngineIon(IntEnum):
    """Ion engine model properties that can be selected as control parameters for a Target Sequence."""

    FLOW_RATE_CONSTANT_TERM = 0
    """FlowRateModel.C0 - the constant coefficient."""
    FLOW_RATE_LINEAR_TERM = 1
    """FlowRateModel.C1 - the linear coefficient."""
    FLOW_RATE_QUADRATIC_TERM = 2
    """FlowRateModel.C2 - the quadratic coefficient."""
    FLOW_RATE_CUBIC_TERM = 3
    """FlowRateModel.C3 - the cubic coefficient."""
    GRAV = 4
    """Gravitational acceleration constant at sea level on the Earth."""
    ISP_CONSTANT_TERM = 5
    """IspModel.C0 - the constant coefficient."""
    ISP_LINEAR_TERM = 6
    """IspModel.C1 - the linear coefficient."""
    ISP_QUADRATIC_TERM = 7
    """IspModel.C2 - the quadratic coefficient."""
    ISP_CUBIC_TERM = 8
    """IspModel.C3 - the cubic coefficient."""
    MASS_FLOW_EFFICIENCY_CONSTANT_TERM = 9
    """MassFlowEfficiencyModel.C0 - the constant coefficient."""
    MASS_FLOW_EFFICIENCY_LINEAR_TERM = 10
    """MassFlowEfficiencyModel.C1 - the linear coefficient."""
    MASS_FLOW_EFFICIENCY_QUADRATIC_TERM = 11
    """MassFlowEfficiencyModel.C2 - the quadratic coefficient."""
    MASS_FLOW_EFFICIENCY_CUBIC_TERM = 12
    """MassFlowEfficiencyModel.C3 - the cubic coefficient."""
    MAX_INPUT_POWER = 13
    """Minimum power required for the engine to produce thrust."""
    MIN_REQUIRED_POWER = 14
    """Maximum power that can be used by the engine to produce thrust."""
    PERCENT_DEGRADATION_PER_YEAR = 15
    """The degradation factor is (1 - x)n, where n is the time since epoch in years, and x is the percent degradation per year."""
    PERCENT_THROTTLE = 16
    """Percentage of available thrust to use (100 is full on, 0 is off)."""
    POWER_EFFICIENCY_CONSTANT_TERM = 17
    """PowerEfficiencyModel.C0 - the constant coefficient."""
    POWER_EFFICIENCY_LINEAR_TERM = 18
    """PowerEfficiencyModel.C1 - the linear coefficient."""
    POWER_EFFICIENCY_QUADRATIC_TERM = 19
    """PowerEfficiencyModel.C2 - the quadratic coefficient."""
    POWER_EFFICIENCY_CUBIC_TERM = 20
    """PowerEfficiencyModel.C3 - the cubic coefficient."""
    REFERENCE_EPOCH = 21
    """The date and time used as a reference epoch for degradation."""

ControlEngineIon.FLOW_RATE_CONSTANT_TERM.__doc__ = "FlowRateModel.C0 - the constant coefficient."
ControlEngineIon.FLOW_RATE_LINEAR_TERM.__doc__ = "FlowRateModel.C1 - the linear coefficient."
ControlEngineIon.FLOW_RATE_QUADRATIC_TERM.__doc__ = "FlowRateModel.C2 - the quadratic coefficient."
ControlEngineIon.FLOW_RATE_CUBIC_TERM.__doc__ = "FlowRateModel.C3 - the cubic coefficient."
ControlEngineIon.GRAV.__doc__ = "Gravitational acceleration constant at sea level on the Earth."
ControlEngineIon.ISP_CONSTANT_TERM.__doc__ = "IspModel.C0 - the constant coefficient."
ControlEngineIon.ISP_LINEAR_TERM.__doc__ = "IspModel.C1 - the linear coefficient."
ControlEngineIon.ISP_QUADRATIC_TERM.__doc__ = "IspModel.C2 - the quadratic coefficient."
ControlEngineIon.ISP_CUBIC_TERM.__doc__ = "IspModel.C3 - the cubic coefficient."
ControlEngineIon.MASS_FLOW_EFFICIENCY_CONSTANT_TERM.__doc__ = "MassFlowEfficiencyModel.C0 - the constant coefficient."
ControlEngineIon.MASS_FLOW_EFFICIENCY_LINEAR_TERM.__doc__ = "MassFlowEfficiencyModel.C1 - the linear coefficient."
ControlEngineIon.MASS_FLOW_EFFICIENCY_QUADRATIC_TERM.__doc__ = "MassFlowEfficiencyModel.C2 - the quadratic coefficient."
ControlEngineIon.MASS_FLOW_EFFICIENCY_CUBIC_TERM.__doc__ = "MassFlowEfficiencyModel.C3 - the cubic coefficient."
ControlEngineIon.MAX_INPUT_POWER.__doc__ = "Minimum power required for the engine to produce thrust."
ControlEngineIon.MIN_REQUIRED_POWER.__doc__ = "Maximum power that can be used by the engine to produce thrust."
ControlEngineIon.PERCENT_DEGRADATION_PER_YEAR.__doc__ = "The degradation factor is (1 - x)n, where n is the time since epoch in years, and x is the percent degradation per year."
ControlEngineIon.PERCENT_THROTTLE.__doc__ = "Percentage of available thrust to use (100 is full on, 0 is off)."
ControlEngineIon.POWER_EFFICIENCY_CONSTANT_TERM.__doc__ = "PowerEfficiencyModel.C0 - the constant coefficient."
ControlEngineIon.POWER_EFFICIENCY_LINEAR_TERM.__doc__ = "PowerEfficiencyModel.C1 - the linear coefficient."
ControlEngineIon.POWER_EFFICIENCY_QUADRATIC_TERM.__doc__ = "PowerEfficiencyModel.C2 - the quadratic coefficient."
ControlEngineIon.POWER_EFFICIENCY_CUBIC_TERM.__doc__ = "PowerEfficiencyModel.C3 - the cubic coefficient."
ControlEngineIon.REFERENCE_EPOCH.__doc__ = "The date and time used as a reference epoch for degradation."

agcls.AgTypeNameMap["ControlEngineIon"] = ControlEngineIon

class ControlEngineModelPolynomial(IntEnum):
    """Polynomial Thrust and Isp engine model properties that can be selected as control parameters for a Target Sequence."""

    THRUST_C0 = 0
    """The thrust C0 coefficient."""
    THRUST_C1 = 1
    """The thrust C1 coefficient."""
    THRUST_C2 = 2
    """The thrust C2 coefficient."""
    THRUST_C3 = 3
    """The thrust C3 coefficient."""
    THRUST_C4 = 4
    """The thrust C4 coefficient."""
    THRUST_C5 = 5
    """The thrust C5 coefficient."""
    THRUST_C6 = 6
    """The thrust C6 coefficient."""
    THRUST_C7 = 7
    """The thrust C7 coefficient."""
    THRUST_B7 = 8
    """The thrust B7 coefficient."""
    THRUST_E4 = 9
    """The thrust E4 coefficient."""
    THRUST_E5 = 10
    """The thrust E5 coefficient."""
    THRUST_E6 = 11
    """The thrust E6 coefficient."""
    THRUST_E7 = 12
    """The thrust E7 coefficient."""
    THRUST_K0 = 13
    """The thrust K0 coefficient."""
    THRUST_K1 = 14
    """The thrust K1 coefficient."""
    THRUST_REFERENCE_TEMPERATURE = 15
    """The thrust reference temperature, Tr."""
    ISP_C0 = 16
    """The specific impulse C0 coefficient."""
    ISP_C1 = 17
    """The specific impulse C1 coefficient."""
    ISP_C2 = 18
    """The specific impulse C2 coefficient."""
    ISP_C3 = 19
    """The specific impulse C3 coefficient."""
    ISP_C4 = 20
    """The specific impulse C4 coefficient."""
    ISP_C5 = 21
    """The specific impulse C5 coefficient."""
    ISP_C6 = 22
    """The specific impulse C6 coefficient."""
    ISP_C7 = 23
    """The specific impulse C7 coefficient."""
    ISP_B7 = 24
    """The specific impulse B7 coefficient."""
    ISP_E4 = 25
    """The specific impulse E4 coefficient."""
    ISP_E5 = 26
    """The specific impulse E5 coefficient."""
    ISP_E6 = 27
    """The specific impulse E6 coefficient."""
    ISP_E7 = 28
    """The specific impulse E7 coefficient."""
    ISP_K0 = 29
    """The specific impulse K0 coefficient."""
    ISP_K1 = 30
    """The specific impulse K1 coefficient."""
    ISP_REFERENCE_TEMP = 31
    """The specific impulse reference temperature, Tr."""
    GRAV = 32
    """The gravitational acceleration constant at sea level on the Earth."""

ControlEngineModelPolynomial.THRUST_C0.__doc__ = "The thrust C0 coefficient."
ControlEngineModelPolynomial.THRUST_C1.__doc__ = "The thrust C1 coefficient."
ControlEngineModelPolynomial.THRUST_C2.__doc__ = "The thrust C2 coefficient."
ControlEngineModelPolynomial.THRUST_C3.__doc__ = "The thrust C3 coefficient."
ControlEngineModelPolynomial.THRUST_C4.__doc__ = "The thrust C4 coefficient."
ControlEngineModelPolynomial.THRUST_C5.__doc__ = "The thrust C5 coefficient."
ControlEngineModelPolynomial.THRUST_C6.__doc__ = "The thrust C6 coefficient."
ControlEngineModelPolynomial.THRUST_C7.__doc__ = "The thrust C7 coefficient."
ControlEngineModelPolynomial.THRUST_B7.__doc__ = "The thrust B7 coefficient."
ControlEngineModelPolynomial.THRUST_E4.__doc__ = "The thrust E4 coefficient."
ControlEngineModelPolynomial.THRUST_E5.__doc__ = "The thrust E5 coefficient."
ControlEngineModelPolynomial.THRUST_E6.__doc__ = "The thrust E6 coefficient."
ControlEngineModelPolynomial.THRUST_E7.__doc__ = "The thrust E7 coefficient."
ControlEngineModelPolynomial.THRUST_K0.__doc__ = "The thrust K0 coefficient."
ControlEngineModelPolynomial.THRUST_K1.__doc__ = "The thrust K1 coefficient."
ControlEngineModelPolynomial.THRUST_REFERENCE_TEMPERATURE.__doc__ = "The thrust reference temperature, Tr."
ControlEngineModelPolynomial.ISP_C0.__doc__ = "The specific impulse C0 coefficient."
ControlEngineModelPolynomial.ISP_C1.__doc__ = "The specific impulse C1 coefficient."
ControlEngineModelPolynomial.ISP_C2.__doc__ = "The specific impulse C2 coefficient."
ControlEngineModelPolynomial.ISP_C3.__doc__ = "The specific impulse C3 coefficient."
ControlEngineModelPolynomial.ISP_C4.__doc__ = "The specific impulse C4 coefficient."
ControlEngineModelPolynomial.ISP_C5.__doc__ = "The specific impulse C5 coefficient."
ControlEngineModelPolynomial.ISP_C6.__doc__ = "The specific impulse C6 coefficient."
ControlEngineModelPolynomial.ISP_C7.__doc__ = "The specific impulse C7 coefficient."
ControlEngineModelPolynomial.ISP_B7.__doc__ = "The specific impulse B7 coefficient."
ControlEngineModelPolynomial.ISP_E4.__doc__ = "The specific impulse E4 coefficient."
ControlEngineModelPolynomial.ISP_E5.__doc__ = "The specific impulse E5 coefficient."
ControlEngineModelPolynomial.ISP_E6.__doc__ = "The specific impulse E6 coefficient."
ControlEngineModelPolynomial.ISP_E7.__doc__ = "The specific impulse E7 coefficient."
ControlEngineModelPolynomial.ISP_K0.__doc__ = "The specific impulse K0 coefficient."
ControlEngineModelPolynomial.ISP_K1.__doc__ = "The specific impulse K1 coefficient."
ControlEngineModelPolynomial.ISP_REFERENCE_TEMP.__doc__ = "The specific impulse reference temperature, Tr."
ControlEngineModelPolynomial.GRAV.__doc__ = "The gravitational acceleration constant at sea level on the Earth."

agcls.AgTypeNameMap["ControlEngineModelPolynomial"] = ControlEngineModelPolynomial

class EngineModelFunction(IntEnum):
    """The engine model function types."""

    ISP = 0
    """Isp as an independent variable of an equation."""
    POWER = 1
    """Power as an independent variable of an equation."""
    ISP_AND_POWER = 2
    """Isp and Power as independent variables of an equation."""

EngineModelFunction.ISP.__doc__ = "Isp as an independent variable of an equation."
EngineModelFunction.POWER.__doc__ = "Power as an independent variable of an equation."
EngineModelFunction.ISP_AND_POWER.__doc__ = "Isp and Power as independent variables of an equation."

agcls.AgTypeNameMap["EngineModelFunction"] = EngineModelFunction

class ThrottleTableOperationMode(IntEnum):
    """Engine operation mode."""

    ENGINE_OPERATION_REG_POLY = 0
    """Interpolation of engine performance data based on a regression polynomial model."""
    ENGINE_OPERATION_PIECEWISE_LINEAR = 1
    """Interpolation of engine performance data based on a piecewise linear model."""
    ENGINE_OPERATION_DISCRETE = 2
    """Discrete engine operation: piecewise constant engine performance as a function of available power."""

ThrottleTableOperationMode.ENGINE_OPERATION_REG_POLY.__doc__ = "Interpolation of engine performance data based on a regression polynomial model."
ThrottleTableOperationMode.ENGINE_OPERATION_PIECEWISE_LINEAR.__doc__ = "Interpolation of engine performance data based on a piecewise linear model."
ThrottleTableOperationMode.ENGINE_OPERATION_DISCRETE.__doc__ = "Discrete engine operation: piecewise constant engine performance as a function of available power."

agcls.AgTypeNameMap["ThrottleTableOperationMode"] = ThrottleTableOperationMode

class IdealOrbitRadius(IntEnum):
    """Ideal Orbit Radius."""

    EPOCH_CENTERED_AVG_SOURCE_RADIUS = 0
    """Epoch centered average source radius."""
    INSTANTANEOUS_CHARACTERISTIC_DISTANCE = 1
    """Instantanous characteristic distance."""

IdealOrbitRadius.EPOCH_CENTERED_AVG_SOURCE_RADIUS.__doc__ = "Epoch centered average source radius."
IdealOrbitRadius.INSTANTANEOUS_CHARACTERISTIC_DISTANCE.__doc__ = "Instantanous characteristic distance."

agcls.AgTypeNameMap["IdealOrbitRadius"] = IdealOrbitRadius

class RotatingCoordinateSystem(IntEnum):
    """Barycenter centered rotating system."""

    BARYCENTER_CENTERED = 0
    """Barycenter centered rotating system."""
    PRIMARY_CENTERED = 1
    """Primary centered rotating system."""
    SECONDARY_CENTERED = 2
    """Secondary centered rotating system."""
    L1_CENTERED = 3
    """L1 centered rotating system."""
    L2_CENTERED = 4
    """L2 centered rotating system."""
    L3_CENTERED = 5
    """L3 centered rotating system."""
    L4_CENTERED = 6
    """L4 centered rotating system."""
    L5_CENTERED = 7
    """L5 centered rotating system."""

RotatingCoordinateSystem.BARYCENTER_CENTERED.__doc__ = "Barycenter centered rotating system."
RotatingCoordinateSystem.PRIMARY_CENTERED.__doc__ = "Primary centered rotating system."
RotatingCoordinateSystem.SECONDARY_CENTERED.__doc__ = "Secondary centered rotating system."
RotatingCoordinateSystem.L1_CENTERED.__doc__ = "L1 centered rotating system."
RotatingCoordinateSystem.L2_CENTERED.__doc__ = "L2 centered rotating system."
RotatingCoordinateSystem.L3_CENTERED.__doc__ = "L3 centered rotating system."
RotatingCoordinateSystem.L4_CENTERED.__doc__ = "L4 centered rotating system."
RotatingCoordinateSystem.L5_CENTERED.__doc__ = "L5 centered rotating system."

agcls.AgTypeNameMap["RotatingCoordinateSystem"] = RotatingCoordinateSystem

class ControlThrusters(IntEnum):
    """Thruster properties that can be selected as control parameters for a Target Sequence."""

    EQUIVALENT_ON_TIME_PERCENT = 0
    """The equivalent on-time percentage is a factor multiplied by the thrust. The thrust is applied continuously throughout the maneuver and is reduced by the percentage. The mass flow rate is likewise reduced."""
    THRUST_EFFICIENCY = 1
    """The thruster efficiency."""
    SPHERICAL_AZIMUTH = 2
    """Thruster direction defined as a vector in the body frame. Spherical azimuth value."""
    SPHERICAL_ELEVATION = 3
    """Thruster direction defined as a vector in the body frame. Spherical elevation value."""
    CARTESIAN_X = 4
    """Thruster direction defined as a vector in the body frame. Cartesian X value."""
    CARTESIAN_Y = 5
    """Thruster direction defined as a vector in the body frame. Cartesian Y value."""
    CARTESIAN_Z = 6
    """Thruster direction defined as a vector in the body frame. Cartesian Z value."""

ControlThrusters.EQUIVALENT_ON_TIME_PERCENT.__doc__ = "The equivalent on-time percentage is a factor multiplied by the thrust. The thrust is applied continuously throughout the maneuver and is reduced by the percentage. The mass flow rate is likewise reduced."
ControlThrusters.THRUST_EFFICIENCY.__doc__ = "The thruster efficiency."
ControlThrusters.SPHERICAL_AZIMUTH.__doc__ = "Thruster direction defined as a vector in the body frame. Spherical azimuth value."
ControlThrusters.SPHERICAL_ELEVATION.__doc__ = "Thruster direction defined as a vector in the body frame. Spherical elevation value."
ControlThrusters.CARTESIAN_X.__doc__ = "Thruster direction defined as a vector in the body frame. Cartesian X value."
ControlThrusters.CARTESIAN_Y.__doc__ = "Thruster direction defined as a vector in the body frame. Cartesian Y value."
ControlThrusters.CARTESIAN_Z.__doc__ = "Thruster direction defined as a vector in the body frame. Cartesian Z value."

agcls.AgTypeNameMap["ControlThrusters"] = ControlThrusters

class ThrusterDirection(IntEnum):
    """The thruster direction type."""

    ACCELERATION = 0
    """The direction that is opposite the direction of the exhaust."""
    EXHAUST = 1
    """The direction of engine exhaust."""

ThrusterDirection.ACCELERATION.__doc__ = "The direction that is opposite the direction of the exhaust."
ThrusterDirection.EXHAUST.__doc__ = "The direction of engine exhaust."

agcls.AgTypeNameMap["ThrusterDirection"] = ThrusterDirection

class Criteria(IntEnum):
    """The criteria type."""

    EQUALS = 0
    """The test parameter must be equal (within the specified tolerance) to the specified value."""
    GREATER_THAN = 1
    """The test parameter must be greater than the specified value."""
    GREATER_THAN_MINIMUM = 2
    """The current value for the calculation object is greater by the specified tolerance than the minimum reached by that object during the segment."""
    LESS_THAN = 3
    """The test parameter must be less than the specified value."""
    LESS_THAN_MAXIMUM = 4
    """The current value for the calculation object is less by the specified tolerance than the maximum reached by that object during the segment."""
    NOT_EQUAL_TO = 5
    """The test parameter must be not equal (within the specified tolerance) to the specified value."""

Criteria.EQUALS.__doc__ = "The test parameter must be equal (within the specified tolerance) to the specified value."
Criteria.GREATER_THAN.__doc__ = "The test parameter must be greater than the specified value."
Criteria.GREATER_THAN_MINIMUM.__doc__ = "The current value for the calculation object is greater by the specified tolerance than the minimum reached by that object during the segment."
Criteria.LESS_THAN.__doc__ = "The test parameter must be less than the specified value."
Criteria.LESS_THAN_MAXIMUM.__doc__ = "The current value for the calculation object is less by the specified tolerance than the maximum reached by that object during the segment."
Criteria.NOT_EQUAL_TO.__doc__ = "The test parameter must be not equal (within the specified tolerance) to the specified value."

agcls.AgTypeNameMap["Criteria"] = Criteria

class ErrorControl(IntEnum):
    """Error Control for the numerical integrator."""

    ABSOLUTE = 0
    """The error estimate of each integrated component is compared to the absolute error tolerance. Error control with this method is based on absolute values, e.g. in meters for position, m/sec for velocity, etc."""
    RELATIVE_BY_COMPONENT = 1
    """The error estimate of each element being integrated relative to the element's value at the start of the step is compared to the relative error tolerance, and the absolute error estimate of each element is compared to the absolute error tolerance."""
    RELATIVE_TO_STATE = 2
    """Relative to State error control."""
    RELATIVE_TO_STEP = 3
    """Error estimate of each integrated component relative to the element's change in value over the step is compared to the relative error tolerance, and the absolute error estimate of each integrated component is compared to the absolute error tolerance."""

ErrorControl.ABSOLUTE.__doc__ = "The error estimate of each integrated component is compared to the absolute error tolerance. Error control with this method is based on absolute values, e.g. in meters for position, m/sec for velocity, etc."
ErrorControl.RELATIVE_BY_COMPONENT.__doc__ = "The error estimate of each element being integrated relative to the element's value at the start of the step is compared to the relative error tolerance, and the absolute error estimate of each element is compared to the absolute error tolerance."
ErrorControl.RELATIVE_TO_STATE.__doc__ = "Relative to State error control."
ErrorControl.RELATIVE_TO_STEP.__doc__ = "Error estimate of each integrated component relative to the element's change in value over the step is compared to the relative error tolerance, and the absolute error estimate of each integrated component is compared to the absolute error tolerance."

agcls.AgTypeNameMap["ErrorControl"] = ErrorControl

class PredictorCorrector(IntEnum):
    """Predictor corrector scheme for the numerical integrator."""

    FULL = 0
    """All force models are re-evaluated at each corrector step."""
    PSEUDO = 1
    """Only the two-body acceleration is re-evaluated at each corrector step."""

PredictorCorrector.FULL.__doc__ = "All force models are re-evaluated at each corrector step."
PredictorCorrector.PSEUDO.__doc__ = "Only the two-body acceleration is re-evaluated at each corrector step."

agcls.AgTypeNameMap["PredictorCorrector"] = PredictorCorrector

class NumericalIntegrator(IntEnum):
    """Numerical integrator type."""

    RUNGE_KUTTA_4TH_ADAPT = 0
    """A 4th order Runge-Kutta integrator, adapting step size by comparing one full step to two half steps. Although this technique can be quite slow compared to the other algorithms, it is very common and can be used for comparison."""
    RUNGE_KUTTA_FEHLBERG_7TH_8TH = 1
    """A 7th order Runge-Kutta-Fehlberg integrator with 8th order error control. This is the default integrator used in the HPOP propagator."""
    RUNGE_KUTTA_VERNER_8TH_9TH = 2
    """A 9th order Runge-Kutta-Verner integrator with 8th order error control."""
    BULIRSCH_STOER = 3
    """An integrator based on Richardson extrapolation with automatic step size control."""
    GAUSS_JACKSON = 4
    """A 12th order Gauss-Jackson integrator for second order ODEs. There is currently no error control implemented for this method, meaning that a fixed step size is used."""
    RUNGE_KUTTA_2ND_3RD = 5
    """A 2nd order Runge-Kutta integrator with 3rd order error control, using Bogacki and Shampine coefficients."""
    RUNGE_KUTTA_4TH_5TH = 6
    """A 4th order Runge-Kutta integrator with 5th order error control, using Cash-Karp coefficients."""
    RUNGE_KUTTA_4TH = 7
    """A 4th order Runge-Kutta integrator that does not employ error control."""

NumericalIntegrator.RUNGE_KUTTA_4TH_ADAPT.__doc__ = "A 4th order Runge-Kutta integrator, adapting step size by comparing one full step to two half steps. Although this technique can be quite slow compared to the other algorithms, it is very common and can be used for comparison."
NumericalIntegrator.RUNGE_KUTTA_FEHLBERG_7TH_8TH.__doc__ = "A 7th order Runge-Kutta-Fehlberg integrator with 8th order error control. This is the default integrator used in the HPOP propagator."
NumericalIntegrator.RUNGE_KUTTA_VERNER_8TH_9TH.__doc__ = "A 9th order Runge-Kutta-Verner integrator with 8th order error control."
NumericalIntegrator.BULIRSCH_STOER.__doc__ = "An integrator based on Richardson extrapolation with automatic step size control."
NumericalIntegrator.GAUSS_JACKSON.__doc__ = "A 12th order Gauss-Jackson integrator for second order ODEs. There is currently no error control implemented for this method, meaning that a fixed step size is used."
NumericalIntegrator.RUNGE_KUTTA_2ND_3RD.__doc__ = "A 2nd order Runge-Kutta integrator with 3rd order error control, using Bogacki and Shampine coefficients."
NumericalIntegrator.RUNGE_KUTTA_4TH_5TH.__doc__ = "A 4th order Runge-Kutta integrator with 5th order error control, using Cash-Karp coefficients."
NumericalIntegrator.RUNGE_KUTTA_4TH.__doc__ = "A 4th order Runge-Kutta integrator that does not employ error control."

agcls.AgTypeNameMap["NumericalIntegrator"] = NumericalIntegrator

class CoeffRungeKuttaV8th9th(IntEnum):
    """Coefficient sets for RKV8th(9th) integrator."""

    COEFFICIENT_1978 = 0
    """SIAM 1978."""
    EFFICIENT = 1
    """Efficient."""

CoeffRungeKuttaV8th9th.COEFFICIENT_1978.__doc__ = "SIAM 1978."
CoeffRungeKuttaV8th9th.EFFICIENT.__doc__ = "Efficient."

agcls.AgTypeNameMap["CoeffRungeKuttaV8th9th"] = CoeffRungeKuttaV8th9th


class IStoppingConditionComponent(object):
    """Properties for a stopping condition."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_stopping_condition_type_method_offset = 1
    _metadata = {
        "iid_data" : (5269503036530625707, 17454438145196234173),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IStoppingConditionComponent."""
        initialize_from_source_object(self, source_object, IStoppingConditionComponent)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IStoppingConditionComponent)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IStoppingConditionComponent, None)

    _get_stopping_condition_type_metadata = { "offset" : _get_stopping_condition_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(StoppingConditionType),) }
    @property
    def stopping_condition_type(self) -> "StoppingConditionType":
        """Get the type of stopping condition."""
        return self._intf.get_property(IStoppingConditionComponent._metadata, IStoppingConditionComponent._get_stopping_condition_type_metadata)

    _property_names[stopping_condition_type] = "stopping_condition_type"


agcls.AgClassCatalog.add_catalog_entry((5269503036530625707, 17454438145196234173), IStoppingConditionComponent)
agcls.AgTypeNameMap["IStoppingConditionComponent"] = IStoppingConditionComponent

class IAttitudeControl(object):
    """Properties for attitude options for a maneuver segment."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_lead_duration_method_offset = 1
    _set_lead_duration_method_offset = 2
    _get_trail_duration_method_offset = 3
    _set_trail_duration_method_offset = 4
    _get_body_axis_method_offset = 5
    _set_body_axis_method_offset = 6
    _get_constraint_sign_method_offset = 7
    _set_constraint_sign_method_offset = 8
    _get_constraint_vector_name_method_offset = 9
    _set_constraint_vector_name_method_offset = 10
    _get_custom_function_method_offset = 11
    _set_custom_function_method_offset = 12
    _metadata = {
        "iid_data" : (4987937969676742434, 14787099081003210654),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAttitudeControl."""
        initialize_from_source_object(self, source_object, IAttitudeControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IAttitudeControl)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAttitudeControl, None)

    _get_lead_duration_metadata = { "offset" : _get_lead_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lead_duration(self) -> float:
        """How long before the maneuver starts the maneuver attitude. Uses Time Dimension."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_lead_duration_metadata)

    _set_lead_duration_metadata = { "offset" : _set_lead_duration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lead_duration.setter
    def lead_duration(self, value:float) -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_lead_duration_metadata, value)

    _get_trail_duration_metadata = { "offset" : _get_trail_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def trail_duration(self) -> float:
        """How long to maintain that attitude after the maneuver. Uses Time Dimension."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_trail_duration_metadata)

    _set_trail_duration_metadata = { "offset" : _set_trail_duration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @trail_duration.setter
    def trail_duration(self, value:float) -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_trail_duration_metadata, value)

    _get_body_axis_metadata = { "offset" : _get_body_axis_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BodyAxis),) }
    @property
    def body_axis(self) -> "BodyAxis":
        """Whether the engine acceleration (the direction opposite the engine's exhaust) is aligned with positive or negative X, Y or Z body axis."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_body_axis_metadata)

    _set_body_axis_metadata = { "offset" : _set_body_axis_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BodyAxis),) }
    @body_axis.setter
    def body_axis(self, value:"BodyAxis") -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_body_axis_metadata, value)

    _get_constraint_sign_metadata = { "offset" : _get_constraint_sign_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ConstraintSign),) }
    @property
    def constraint_sign(self) -> "ConstraintSign":
        """Whether the Constraint Vector is positive or negative."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_constraint_sign_metadata)

    _set_constraint_sign_metadata = { "offset" : _set_constraint_sign_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ConstraintSign),) }
    @constraint_sign.setter
    def constraint_sign(self, value:"ConstraintSign") -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_constraint_sign_metadata, value)

    _get_constraint_vector_name_metadata = { "offset" : _get_constraint_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def constraint_vector_name(self) -> str:
        """Constraint Vector - the vector toward which this body vector is constrained."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_constraint_vector_name_metadata)

    _set_constraint_vector_name_metadata = { "offset" : _set_constraint_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @constraint_vector_name.setter
    def constraint_vector_name(self, value:str) -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_constraint_vector_name_metadata, value)

    _get_custom_function_metadata = { "offset" : _get_custom_function_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CustomFunction),) }
    @property
    def custom_function(self) -> "CustomFunction":
        """Get or set the attitude definition to use for other STK functions."""
        return self._intf.get_property(IAttitudeControl._metadata, IAttitudeControl._get_custom_function_metadata)

    _set_custom_function_metadata = { "offset" : _set_custom_function_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CustomFunction),) }
    @custom_function.setter
    def custom_function(self, value:"CustomFunction") -> None:
        return self._intf.set_property(IAttitudeControl._metadata, IAttitudeControl._set_custom_function_metadata, value)

    _property_names[lead_duration] = "lead_duration"
    _property_names[trail_duration] = "trail_duration"
    _property_names[body_axis] = "body_axis"
    _property_names[constraint_sign] = "constraint_sign"
    _property_names[constraint_vector_name] = "constraint_vector_name"
    _property_names[custom_function] = "custom_function"


agcls.AgClassCatalog.add_catalog_entry((4987937969676742434, 14787099081003210654), IAttitudeControl)
agcls.AgTypeNameMap["IAttitudeControl"] = IAttitudeControl

class IAttitudeControlFinite(IAttitudeControl):
    """The attitude control of a finite maneuver."""

    _num_methods = 0
    _vtable_offset = IAttitudeControl._vtable_offset + IAttitudeControl._num_methods
    _metadata = {
        "iid_data" : (5056364145348131654, 13409090031304170403),
        "vtable_reference" : IAttitudeControl._vtable_offset + IAttitudeControl._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAttitudeControlFinite."""
        initialize_from_source_object(self, source_object, IAttitudeControlFinite)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControl._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IAttitudeControlFinite)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAttitudeControlFinite, IAttitudeControl)



agcls.AgClassCatalog.add_catalog_entry((5056364145348131654, 13409090031304170403), IAttitudeControlFinite)
agcls.AgTypeNameMap["IAttitudeControlFinite"] = IAttitudeControlFinite

class IAttitudeControlImpulsive(IAttitudeControl):
    """The attitude control of an impulsive maneuver."""

    _num_methods = 0
    _vtable_offset = IAttitudeControl._vtable_offset + IAttitudeControl._num_methods
    _metadata = {
        "iid_data" : (4710479165606193296, 7418419355563075998),
        "vtable_reference" : IAttitudeControl._vtable_offset + IAttitudeControl._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAttitudeControlImpulsive."""
        initialize_from_source_object(self, source_object, IAttitudeControlImpulsive)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControl._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IAttitudeControlImpulsive)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAttitudeControlImpulsive, IAttitudeControl)



agcls.AgClassCatalog.add_catalog_entry((4710479165606193296, 7418419355563075998), IAttitudeControlImpulsive)
agcls.AgTypeNameMap["IAttitudeControlImpulsive"] = IAttitudeControlImpulsive

class IAttitudeControlOptimalFinite(IAttitudeControl):
    """The attitude control of a optimal finite maneuver."""

    _num_methods = 0
    _vtable_offset = IAttitudeControl._vtable_offset + IAttitudeControl._num_methods
    _metadata = {
        "iid_data" : (5442963331835446219, 1789868880099233963),
        "vtable_reference" : IAttitudeControl._vtable_offset + IAttitudeControl._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAttitudeControlOptimalFinite."""
        initialize_from_source_object(self, source_object, IAttitudeControlOptimalFinite)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControl._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IAttitudeControlOptimalFinite)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAttitudeControlOptimalFinite, IAttitudeControl)



agcls.AgClassCatalog.add_catalog_entry((5442963331835446219, 1789868880099233963), IAttitudeControlOptimalFinite)
agcls.AgTypeNameMap["IAttitudeControlOptimalFinite"] = IAttitudeControlOptimalFinite

class IManeuver(object):
    """Properties of an Impulsive Maneuver Segment."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_attitude_control_type_method_offset = 1
    _set_attitude_control_type_method_offset = 2
    _get_attitude_control_method_offset = 3
    _get_propulsion_method_method_offset = 4
    _set_propulsion_method_method_offset = 5
    _get_propulsion_method_value_method_offset = 6
    _metadata = {
        "iid_data" : (4677218856107458942, 12562241327114738828),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IManeuver."""
        initialize_from_source_object(self, source_object, IManeuver)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IManeuver)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IManeuver, None)

    _get_attitude_control_type_metadata = { "offset" : _get_attitude_control_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AttitudeControl),) }
    @property
    def attitude_control_type(self) -> "AttitudeControl":
        """Determine the attitude parameters available for you to specify."""
        return self._intf.get_property(IManeuver._metadata, IManeuver._get_attitude_control_type_metadata)

    _set_attitude_control_type_metadata = { "offset" : _set_attitude_control_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AttitudeControl),) }
    def set_attitude_control_type(self, attitude_control_type:"AttitudeControl") -> None:
        """Set the attitude control type."""
        return self._intf.invoke(IManeuver._metadata, IManeuver._set_attitude_control_type_metadata, attitude_control_type)

    _get_attitude_control_metadata = { "offset" : _get_attitude_control_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def attitude_control(self) -> "IAttitudeControl":
        """Get the attitude control properties collection."""
        return self._intf.get_property(IManeuver._metadata, IManeuver._get_attitude_control_metadata)

    _get_propulsion_method_metadata = { "offset" : _get_propulsion_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PropulsionMethod),) }
    @property
    def propulsion_method(self) -> "PropulsionMethod":
        """Get the propulsion type to be modeled."""
        return self._intf.get_property(IManeuver._metadata, IManeuver._get_propulsion_method_metadata)

    _set_propulsion_method_metadata = { "offset" : _set_propulsion_method_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR,),
            "marshallers" : (agmarshall.EnumArg(PropulsionMethod), agmarshall.BStrArg,) }
    def set_propulsion_method(self, propulsion_method:"PropulsionMethod", value:str) -> None:
        """Set the propulsion type and associated engine/thruster set."""
        return self._intf.invoke(IManeuver._metadata, IManeuver._set_propulsion_method_metadata, propulsion_method, value)

    _get_propulsion_method_value_metadata = { "offset" : _get_propulsion_method_value_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propulsion_method_value(self) -> str:
        """Get the specific engine model or thruster set to be used for the maneuver."""
        return self._intf.get_property(IManeuver._metadata, IManeuver._get_propulsion_method_value_metadata)

    _property_names[attitude_control_type] = "attitude_control_type"
    _property_names[attitude_control] = "attitude_control"
    _property_names[propulsion_method] = "propulsion_method"
    _property_names[propulsion_method_value] = "propulsion_method_value"


agcls.AgClassCatalog.add_catalog_entry((4677218856107458942, 12562241327114738828), IManeuver)
agcls.AgTypeNameMap["IManeuver"] = IManeuver

class IDisplaySystem(object):
    """The launch coordinate system."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4713357538953774204, 7691016069329601429),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IDisplaySystem."""
        initialize_from_source_object(self, source_object, IDisplaySystem)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IDisplaySystem)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IDisplaySystem, None)



agcls.AgClassCatalog.add_catalog_entry((4713357538953774204, 7691016069329601429), IDisplaySystem)
agcls.AgTypeNameMap["IDisplaySystem"] = IDisplaySystem

class IBurnout(object):
    """The burnout point reference frame."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4768490459946272698, 6896606911126661053),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IBurnout."""
        initialize_from_source_object(self, source_object, IBurnout)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IBurnout)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IBurnout, None)



agcls.AgClassCatalog.add_catalog_entry((4768490459946272698, 6896606911126661053), IBurnout)
agcls.AgTypeNameMap["IBurnout"] = IBurnout

class IElement(object):
    """The elements of the selected coordinate type."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5488204777371386664, 9539562261869440956),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IElement."""
        initialize_from_source_object(self, source_object, IElement)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IElement)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IElement, None)



agcls.AgClassCatalog.add_catalog_entry((5488204777371386664, 9539562261869440956), IElement)
agcls.AgTypeNameMap["IElement"] = IElement

class IMCSSegment(object):
    """General properties for segments."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_type_method_offset = 1
    _get_properties_method_offset = 2
    _get_initial_state_method_offset = 3
    _get_final_state_method_offset = 4
    _get_result_value_method_offset = 5
    _run_method_offset = 6
    _get_results_method_offset = 7
    _get_segment_summary_method_offset = 8
    _metadata = {
        "iid_data" : (5363594983371740097, 13023539001208839335),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IMCSSegment."""
        initialize_from_source_object(self, source_object, IMCSSegment)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IMCSSegment)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IMCSSegment, None)

    _get_type_metadata = { "offset" : _get_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentType),) }
    @property
    def type(self) -> "SegmentType":
        """Return the type of segment."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_type_metadata)

    _get_properties_metadata = { "offset" : _get_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def properties(self) -> "MCSSegmentProperties":
        """Return the properties of the segment."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_properties_metadata)

    _get_initial_state_metadata = { "offset" : _get_initial_state_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def initial_state(self) -> "State":
        """Get the initial state of the segment."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_initial_state_metadata)

    _get_final_state_metadata = { "offset" : _get_final_state_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def final_state(self) -> "State":
        """Get the final state of the segment."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_final_state_metadata)

    _get_result_value_metadata = { "offset" : _get_result_value_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg,) }
    def get_result_value(self, result_name:str) -> typing.Any:
        """Return a result value."""
        return self._intf.invoke(IMCSSegment._metadata, IMCSSegment._get_result_value_metadata, result_name, OutArg())

    _run_metadata = { "offset" : _run_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def run(self) -> "State":
        """Run the segment in individual segment mode.  See MCSDriver."""
        return self._intf.invoke(IMCSSegment._metadata, IMCSSegment._run_metadata, OutArg())

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "CalculationObjectCollection":
        """Get the results of the segment."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_results_metadata)

    _get_segment_summary_metadata = { "offset" : _get_segment_summary_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segment_summary(self) -> "IDataProviderResult":
        """Get the segment summary report."""
        return self._intf.get_property(IMCSSegment._metadata, IMCSSegment._get_segment_summary_metadata)

    _property_names[type] = "type"
    _property_names[properties] = "properties"
    _property_names[initial_state] = "initial_state"
    _property_names[final_state] = "final_state"
    _property_names[results] = "results"
    _property_names[segment_summary] = "segment_summary"


agcls.AgClassCatalog.add_catalog_entry((5363594983371740097, 13023539001208839335), IMCSSegment)
agcls.AgTypeNameMap["IMCSSegment"] = IMCSSegment

class IMCSSequence(object):
    """Properties for a Sequence segment."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_repeat_count_method_offset = 1
    _set_repeat_count_method_offset = 2
    _get_generate_ephemeris_method_offset = 3
    _set_generate_ephemeris_method_offset = 4
    _get_segments_method_offset = 5
    _get_sequence_state_to_pass_method_offset = 6
    _set_sequence_state_to_pass_method_offset = 7
    _get_scripting_tool_method_offset = 8
    _apply_script_method_offset = 9
    _metadata = {
        "iid_data" : (5582283013374644007, 10842020077807962011),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IMCSSequence."""
        initialize_from_source_object(self, source_object, IMCSSequence)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IMCSSequence)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IMCSSequence, None)

    _get_repeat_count_metadata = { "offset" : _get_repeat_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def repeat_count(self) -> int:
        """Get or set the number of times that the sequence will be executed. A sequence that is repeated is executed immediately subsequent to the previous execution of the sequence. Dimensionless."""
        return self._intf.get_property(IMCSSequence._metadata, IMCSSequence._get_repeat_count_metadata)

    _set_repeat_count_metadata = { "offset" : _set_repeat_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @repeat_count.setter
    def repeat_count(self, value:int) -> None:
        return self._intf.set_property(IMCSSequence._metadata, IMCSSequence._set_repeat_count_metadata, value)

    _get_generate_ephemeris_metadata = { "offset" : _get_generate_ephemeris_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def generate_ephemeris(self) -> bool:
        """If true, the sequence generates ephemeris and displays it in the 2D and 3D Graphics windows."""
        return self._intf.get_property(IMCSSequence._metadata, IMCSSequence._get_generate_ephemeris_metadata)

    _set_generate_ephemeris_metadata = { "offset" : _set_generate_ephemeris_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @generate_ephemeris.setter
    def generate_ephemeris(self, value:bool) -> None:
        return self._intf.set_property(IMCSSequence._metadata, IMCSSequence._set_generate_ephemeris_metadata, value)

    _get_segments_metadata = { "offset" : _get_segments_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segments(self) -> "MCSSegmentCollection":
        """Get the list of segments defined for the sequence."""
        return self._intf.get_property(IMCSSequence._metadata, IMCSSequence._get_segments_metadata)

    _get_sequence_state_to_pass_metadata = { "offset" : _get_sequence_state_to_pass_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SequenceStateToPass),) }
    @property
    def sequence_state_to_pass(self) -> "SequenceStateToPass":
        """State To Pass To Next Segment - the state of the sequence to pass."""
        return self._intf.get_property(IMCSSequence._metadata, IMCSSequence._get_sequence_state_to_pass_metadata)

    _set_sequence_state_to_pass_metadata = { "offset" : _set_sequence_state_to_pass_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SequenceStateToPass),) }
    @sequence_state_to_pass.setter
    def sequence_state_to_pass(self, value:"SequenceStateToPass") -> None:
        return self._intf.set_property(IMCSSequence._metadata, IMCSSequence._set_sequence_state_to_pass_metadata, value)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(IMCSSequence._metadata, IMCSSequence._get_scripting_tool_metadata)

    _apply_script_metadata = { "offset" : _apply_script_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_script(self) -> None:
        """Apply the script."""
        return self._intf.invoke(IMCSSequence._metadata, IMCSSequence._apply_script_metadata, )

    _property_names[repeat_count] = "repeat_count"
    _property_names[generate_ephemeris] = "generate_ephemeris"
    _property_names[segments] = "segments"
    _property_names[sequence_state_to_pass] = "sequence_state_to_pass"
    _property_names[scripting_tool] = "scripting_tool"


agcls.AgClassCatalog.add_catalog_entry((5582283013374644007, 10842020077807962011), IMCSSequence)
agcls.AgTypeNameMap["IMCSSequence"] = IMCSSequence

class IProfile(object):
    """General properties for target sequence profiles."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _copy_method_offset = 1
    _get_name_method_offset = 2
    _set_name_method_offset = 3
    _get_status_method_offset = 4
    _get_user_comment_method_offset = 5
    _set_user_comment_method_offset = 6
    _get_mode_method_offset = 7
    _set_mode_method_offset = 8
    _get_type_method_offset = 9
    _metadata = {
        "iid_data" : (4686877490284796494, 11687945607961083032),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IProfile."""
        initialize_from_source_object(self, source_object, IProfile)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, IProfile)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IProfile, None)

    _copy_metadata = { "offset" : _copy_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def copy(self) -> "IProfile":
        """Make a copy of the profile."""
        return self._intf.invoke(IProfile._metadata, IProfile._copy_metadata, OutArg())

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get or set the name of the profile."""
        return self._intf.get_property(IProfile._metadata, IProfile._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        return self._intf.set_property(IProfile._metadata, IProfile._set_name_metadata, value)

    _get_status_metadata = { "offset" : _get_status_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def status(self) -> str:
        """Get or set the status of the profile."""
        return self._intf.get_property(IProfile._metadata, IProfile._get_status_metadata)

    _get_user_comment_metadata = { "offset" : _get_user_comment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_comment(self) -> str:
        """A user comment."""
        return self._intf.get_property(IProfile._metadata, IProfile._get_user_comment_metadata)

    _set_user_comment_metadata = { "offset" : _set_user_comment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_comment.setter
    def user_comment(self, value:str) -> None:
        return self._intf.set_property(IProfile._metadata, IProfile._set_user_comment_metadata, value)

    _get_mode_metadata = { "offset" : _get_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ProfileMode),) }
    @property
    def mode(self) -> "ProfileMode":
        """Get or set the profile's mode."""
        return self._intf.get_property(IProfile._metadata, IProfile._get_mode_metadata)

    _set_mode_metadata = { "offset" : _set_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ProfileMode),) }
    @mode.setter
    def mode(self, value:"ProfileMode") -> None:
        return self._intf.set_property(IProfile._metadata, IProfile._set_mode_metadata, value)

    _get_type_metadata = { "offset" : _get_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Profile),) }
    @property
    def type(self) -> "Profile":
        """Return the current profile type."""
        return self._intf.get_property(IProfile._metadata, IProfile._get_type_metadata)

    _property_names[name] = "name"
    _property_names[status] = "status"
    _property_names[user_comment] = "user_comment"
    _property_names[mode] = "mode"
    _property_names[type] = "type"


agcls.AgClassCatalog.add_catalog_entry((4686877490284796494, 11687945607961083032), IProfile)
agcls.AgTypeNameMap["IProfile"] = IProfile

class ICentralBodyComponentEphemeris(object):
    """The central body ephemeris source."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5592778241070953614, 10499311837320329628),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICentralBodyComponentEphemeris."""
        initialize_from_source_object(self, source_object, ICentralBodyComponentEphemeris)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, ICentralBodyComponentEphemeris)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICentralBodyComponentEphemeris, None)



agcls.AgClassCatalog.add_catalog_entry((5592778241070953614, 10499311837320329628), ICentralBodyComponentEphemeris)
agcls.AgTypeNameMap["ICentralBodyComponentEphemeris"] = ICentralBodyComponentEphemeris

class ICentralBodyComponentShape(object):
    """The central body shape."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4933547587540680255, 5573209392764395165),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICentralBodyComponentShape."""
        initialize_from_source_object(self, source_object, ICentralBodyComponentShape)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, ICentralBodyComponentShape)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICentralBodyComponentShape, None)



agcls.AgClassCatalog.add_catalog_entry((4933547587540680255, 5573209392764395165), ICentralBodyComponentShape)
agcls.AgTypeNameMap["ICentralBodyComponentShape"] = ICentralBodyComponentShape

class ICentralBodyComponentAttitude(object):
    """The central body attitude."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5344723028474245754, 5582255056768029873),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICentralBodyComponentAttitude."""
        initialize_from_source_object(self, source_object, ICentralBodyComponentAttitude)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, ICentralBodyComponentAttitude)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICentralBodyComponentAttitude, None)



agcls.AgClassCatalog.add_catalog_entry((5344723028474245754, 5582255056768029873), ICentralBodyComponentAttitude)
agcls.AgTypeNameMap["ICentralBodyComponentAttitude"] = ICentralBodyComponentAttitude

class ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides(ICentralBodyComponentEphemeris):
    """Properties for the JPL DE ephemeris source."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods
    _get_jplde_filename_method_offset = 1
    _set_jplde_filename_method_offset = 2
    _metadata = {
        "iid_data" : (5096958885497432761, 15383033303903279551),
        "vtable_reference" : ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides."""
        initialize_from_source_object(self, source_object, ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides, ICentralBodyComponentEphemeris)

    _get_jplde_filename_metadata = { "offset" : _get_jplde_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def jplde_filename(self) -> str:
        """Get or set the DE file name."""
        return self._intf.get_property(ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides._metadata, ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides._get_jplde_filename_metadata)

    _set_jplde_filename_metadata = { "offset" : _set_jplde_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @jplde_filename.setter
    def jplde_filename(self, value:str) -> None:
        return self._intf.set_property(ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides._metadata, ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides._set_jplde_filename_metadata, value)

    _property_names[jplde_filename] = "jplde_filename"


agcls.AgClassCatalog.add_catalog_entry((5096958885497432761, 15383033303903279551), ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides)
agcls.AgTypeNameMap["ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides"] = ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides

class INumericalIntegrator(object):
    """The type of numerical integrator to be used by the propagator."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4724514531705891614, 6171053309445421234),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type INumericalIntegrator."""
        initialize_from_source_object(self, source_object, INumericalIntegrator)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def _get_property(self, attrname):
        return get_interface_property(attrname, INumericalIntegrator)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, INumericalIntegrator, None)



agcls.AgClassCatalog.add_catalog_entry((4724514531705891614, 6171053309445421234), INumericalIntegrator)
agcls.AgTypeNameMap["INumericalIntegrator"] = INumericalIntegrator



class MCSDriver(IPropagator, SupportsDeleteCallback):
    """
    Properties for the Mission Control Sequence.

    Examples
    --------
    Set satellite propagator to Astrogator and clear segments:
    >>> # Satellite satellite: Satellite object
    >>> satellite.set_propagator_type(PropagatorType.ASTROGATOR)
    >>> driver = satellite.propagator
    >>> # Clear all segments from the MCS
    >>> driver.main_sequence.remove_all()

    Run the Astrogator® mission control sequence (MCS):
    >>> # MCSDriver driver: MCS driver interface
    >>> driver.run_mcs()
    """

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_main_sequence_method_offset = 1
    _get_options_method_offset = 2
    _get_auto_sequence_method_offset = 3
    _run_mcs_method_offset = 4
    _begin_run_method_offset = 5
    _end_run_method_offset = 6
    _clear_draw_while_calculating_graphics_method_offset = 7
    _reset_all_profiles_method_offset = 8
    _apply_all_profile_changes_method_offset = 9
    _append_run_method_offset = 10
    _append_run_from_time_method_offset = 11
    _append_run_from_state_method_offset = 12
    _run_mcs2_method_offset = 13
    _get_calculation_graphs_method_offset = 14
    _metadata = {
        "iid_data" : (5434593673786300345, 9884445645793902248),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSDriver)

    _get_main_sequence_metadata = { "offset" : _get_main_sequence_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def main_sequence(self) -> "MCSSegmentCollection":
        """Get the Mission Control Sequence."""
        return self._intf.get_property(MCSDriver._metadata, MCSDriver._get_main_sequence_metadata)

    _get_options_metadata = { "offset" : _get_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def options(self) -> "MCSOptions":
        """Get the Mission Control Sequence options."""
        return self._intf.get_property(MCSDriver._metadata, MCSDriver._get_options_metadata)

    _get_auto_sequence_metadata = { "offset" : _get_auto_sequence_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def auto_sequence(self) -> "AutomaticSequenceCollection":
        """Get the Automatic Sequences."""
        return self._intf.get_property(MCSDriver._metadata, MCSDriver._get_auto_sequence_metadata)

    _run_mcs_metadata = { "offset" : _run_mcs_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def run_mcs(self) -> None:
        """Run the current MCS."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._run_mcs_metadata, )

    _begin_run_metadata = { "offset" : _begin_run_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def begin_run(self) -> None:
        """Begins an individual segment mode run."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._begin_run_metadata, )

    _end_run_metadata = { "offset" : _end_run_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def end_run(self) -> None:
        """End an individual segment mode run."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._end_run_metadata, )

    _clear_draw_while_calculating_graphics_metadata = { "offset" : _clear_draw_while_calculating_graphics_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def clear_draw_while_calculating_graphics(self) -> None:
        """Clear the draw while calculating graphics."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._clear_draw_while_calculating_graphics_metadata, )

    _reset_all_profiles_metadata = { "offset" : _reset_all_profiles_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def reset_all_profiles(self) -> None:
        """Reset all active profiles in all target sequences."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._reset_all_profiles_metadata, )

    _apply_all_profile_changes_metadata = { "offset" : _apply_all_profile_changes_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_all_profile_changes(self) -> None:
        """Apply all active profile changes in all target sequences."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._apply_all_profile_changes_metadata, )

    _append_run_metadata = { "offset" : _append_run_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def append_run(self) -> None:
        """Append the existing ephemeris with another individual segment mode run."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._append_run_metadata, )

    _append_run_from_time_metadata = { "offset" : _append_run_from_time_method_offset,
            "arg_types" : (agcom.Variant, agcom.LONG,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.EnumArg(ClearEphemerisDirection),) }
    def append_run_from_time(self, epoch:typing.Any, clear_ephemeris_direction:"ClearEphemerisDirection") -> None:
        """Append the existing ephemeris with another individual segment mode run, starting at a specified time. Ephemeris is cleared from time based on clear direction."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._append_run_from_time_metadata, epoch, clear_ephemeris_direction)

    _append_run_from_state_metadata = { "offset" : _append_run_from_state_method_offset,
            "arg_types" : (agcom.PVOID, agcom.LONG,),
            "marshallers" : (agmarshall.InterfaceInArg("State"), agmarshall.EnumArg(ClearEphemerisDirection),) }
    def append_run_from_state(self, append_state:"State", clear_ephemeris_direction:"ClearEphemerisDirection") -> None:
        """Append the existing ephemeris with another individual segment mode run, starting at a specified state. Ephemeris is cleared from time based on clear direction."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._append_run_from_state_metadata, append_state, clear_ephemeris_direction)

    _run_mcs2_metadata = { "offset" : _run_mcs2_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RunCode),) }
    def run_mcs2(self) -> "RunCode":
        """Run the current MCS and returns an error code."""
        return self._intf.invoke(MCSDriver._metadata, MCSDriver._run_mcs2_metadata, OutArg())

    _get_calculation_graphs_metadata = { "offset" : _get_calculation_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_graphs(self) -> "CalculationGraphCollection":
        """Get the calculation graphs."""
        return self._intf.get_property(MCSDriver._metadata, MCSDriver._get_calculation_graphs_metadata)

    _property_names[main_sequence] = "main_sequence"
    _property_names[options] = "options"
    _property_names[auto_sequence] = "auto_sequence"
    _property_names[calculation_graphs] = "calculation_graphs"

    def __init__(self, source_object=None):
        """Construct an object of type MCSDriver."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSDriver)
        IPropagator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IPropagator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSDriver, [MCSDriver, IPropagator])

agcls.AgClassCatalog.add_catalog_entry((5389292584719371376, 5476973722651125132), MCSDriver)
agcls.AgTypeNameMap["MCSDriver"] = MCSDriver

class MCSSegmentCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a collection of segments."""

    _num_methods = 13
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _insert_method_offset = 2
    _remove_method_offset = 3
    _remove_all_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _cut_method_offset = 7
    _paste_method_offset = 8
    _insert_copy_method_offset = 9
    _insert_by_name_method_offset = 10
    _get_provide_runtime_type_info_method_offset = 11
    _get_item_by_index_method_offset = 12
    _get_item_by_name_method_offset = 13
    _metadata = {
        "iid_data" : (5058380971033415851, 1014008794519657865),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSSegmentCollection)
    def __iter__(self):
        """Create an iterator for the MCSSegmentCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IMCSSegment":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "IMCSSegment":
        """Return the specified segment(using segment name or index number)."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._item_metadata, index_or_name, OutArg())

    _insert_metadata = { "offset" : _insert_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(SegmentType), agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def insert(self, segment_type:"SegmentType", segment_name:str, segment_to_insert_before:str) -> "IMCSSegment":
        """Add a segment to the segment collection."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._insert_metadata, segment_type, segment_name, segment_to_insert_before, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove(self, segment_name_to_remove:str) -> None:
        """Remove a segment; the End segment cannot be deleted."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._remove_metadata, segment_name_to_remove)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all segments; the End segment cannot be deleted."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._remove_all_metadata, )

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(MCSSegmentCollection._metadata, MCSSegmentCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(MCSSegmentCollection._metadata, MCSSegmentCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def cut(self, segment_name_to_cut:str) -> None:
        """Copy the segment into the clipboard and removes the segment from the sequence."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._cut_metadata, segment_name_to_cut)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def paste(self, segment_to_paste_before:str) -> "IMCSSegment":
        """Pastes the segment from the clipboard and inserts in before the given segment name."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._paste_metadata, segment_to_paste_before, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IMCSSegment"), agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def insert_copy(self, segment:"IMCSSegment", segment_to_insert_before:str) -> "IMCSSegment":
        """Copy the segment pointer and inserts the copy before the given segment name."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._insert_copy_metadata, segment, segment_to_insert_before, OutArg())

    _insert_by_name_metadata = { "offset" : _insert_by_name_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def insert_by_name(self, segment_name:str, segment_to_insert_before:str) -> "IMCSSegment":
        """Insert a segment by name to the segment collection."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._insert_by_name_metadata, segment_name, segment_to_insert_before, OutArg())

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(MCSSegmentCollection._metadata, MCSSegmentCollection._get_provide_runtime_type_info_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "IMCSSegment":
        """Retrieve the specified segment(using segment index number)."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "IMCSSegment":
        """Retrieve the specified segment(using segment name)."""
        return self._intf.invoke(MCSSegmentCollection._metadata, MCSSegmentCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type MCSSegmentCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSSegmentCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSSegmentCollection, [MCSSegmentCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4909520030354968962, 14065348172908224678), MCSSegmentCollection)
agcls.AgTypeNameMap["MCSSegmentCollection"] = MCSSegmentCollection

class MCSEnd(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, SupportsDeleteCallback):
    """Properties for an End segment."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5377430998049428360, 10736208053127098559),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSEnd)


    def __init__(self, source_object=None):
        """Construct an object of type MCSEnd."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSEnd)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSEnd, [MCSEnd, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo])

agcls.AgClassCatalog.add_catalog_entry((4611836544222750290, 3791847305781604787), MCSEnd)
agcls.AgTypeNameMap["MCSEnd"] = MCSEnd

class MCSInitialState(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Initial State segment."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_orbit_epoch_method_offset = 3
    _set_orbit_epoch_method_offset = 4
    _get_spacecraft_parameters_method_offset = 5
    _get_fuel_tank_method_offset = 6
    _get_element_type_method_offset = 7
    _set_element_type_method_offset = 8
    _get_element_method_offset = 9
    _enable_control_parameter_method_offset = 10
    _disable_control_parameter_method_offset = 11
    _is_control_parameter_enabled_method_offset = 12
    _get_control_parameters_available_method_offset = 13
    _get_user_variables_method_offset = 14
    _metadata = {
        "iid_data" : (5028451386241945120, 18244435719331815809),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSInitialState)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(MCSInitialState._metadata, MCSInitialState._set_coord_system_name_metadata, value)

    _get_orbit_epoch_metadata = { "offset" : _get_orbit_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def orbit_epoch(self) -> typing.Any:
        """Get or set the orbit epoch. Uses DateFormat Dimension."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_orbit_epoch_metadata)

    _set_orbit_epoch_metadata = { "offset" : _set_orbit_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @orbit_epoch.setter
    def orbit_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(MCSInitialState._metadata, MCSInitialState._set_orbit_epoch_metadata, value)

    _get_spacecraft_parameters_metadata = { "offset" : _get_spacecraft_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def spacecraft_parameters(self) -> "SpacecraftParameters":
        """Get the spacecraft  parameters."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_spacecraft_parameters_metadata)

    _get_fuel_tank_metadata = { "offset" : _get_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_tank(self) -> "FuelTank":
        """Get the fuel tank parameters."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_fuel_tank_metadata)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementSetType),) }
    @property
    def element_type(self) -> "ElementSetType":
        """Get the coordinate type."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementSetType),) }
    def set_element_type(self, element_type:"ElementSetType") -> None:
        """Select an coordinate type."""
        return self._intf.invoke(MCSInitialState._metadata, MCSInitialState._set_element_type_metadata, element_type)

    _get_element_metadata = { "offset" : _get_element_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def element(self) -> "IElement":
        """Get the elements of the selected coordinate type."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_element_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlInitState),) }
    def enable_control_parameter(self, param:"ControlInitState") -> None:
        """Enable a control parameter."""
        return self._intf.invoke(MCSInitialState._metadata, MCSInitialState._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlInitState),) }
    def disable_control_parameter(self, param:"ControlInitState") -> None:
        """Disables a control parameter."""
        return self._intf.invoke(MCSInitialState._metadata, MCSInitialState._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlInitState), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlInitState") -> bool:
        """Sees if a control is enabled."""
        return self._intf.invoke(MCSInitialState._metadata, MCSInitialState._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_control_parameters_available_metadata)

    _get_user_variables_metadata = { "offset" : _get_user_variables_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_variables(self) -> "UserVariableCollection":
        """Interface used to modify user variables for the initial state segment."""
        return self._intf.get_property(MCSInitialState._metadata, MCSInitialState._get_user_variables_metadata)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[orbit_epoch] = "orbit_epoch"
    _property_names[spacecraft_parameters] = "spacecraft_parameters"
    _property_names[fuel_tank] = "fuel_tank"
    _property_names[element_type] = "element_type"
    _property_names[element] = "element"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[user_variables] = "user_variables"

    def __init__(self, source_object=None):
        """Construct an object of type MCSInitialState."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSInitialState)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSInitialState, [MCSInitialState, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5119690725327440606, 12426330438899630259), MCSInitialState)
agcls.AgTypeNameMap["MCSInitialState"] = MCSInitialState

class SpacecraftParameters(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for spacecraft configuration."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_dry_mass_method_offset = 1
    _set_dry_mass_method_offset = 2
    _get_cd_method_offset = 3
    _set_cd_method_offset = 4
    _get_drag_area_method_offset = 5
    _set_drag_area_method_offset = 6
    _get_cr_method_offset = 7
    _set_cr_method_offset = 8
    _get_solar_radiation_pressure_area_method_offset = 9
    _set_solar_radiation_pressure_area_method_offset = 10
    _get_ck_method_offset = 11
    _set_ck_method_offset = 12
    _get_radiation_pressure_area_method_offset = 13
    _set_radiation_pressure_area_method_offset = 14
    _get_k1_method_offset = 15
    _set_k1_method_offset = 16
    _get_k2_method_offset = 17
    _set_k2_method_offset = 18
    _metadata = {
        "iid_data" : (5571064856599243066, 14979986637316024483),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SpacecraftParameters)

    _get_dry_mass_metadata = { "offset" : _get_dry_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def dry_mass(self) -> float:
        """Get or set the mass of the spacecraft exclusive of propellant. Uses Mass Dimension."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_dry_mass_metadata)

    _set_dry_mass_metadata = { "offset" : _set_dry_mass_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @dry_mass.setter
    def dry_mass(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_dry_mass_metadata, value)

    _get_cd_metadata = { "offset" : _get_cd_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd(self) -> float:
        """Get or set the dimensionless drag coefficient associated with the drag area. Dimensionless."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_cd_metadata)

    _set_cd_metadata = { "offset" : _set_cd_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd.setter
    def cd(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_cd_metadata, value)

    _get_drag_area_metadata = { "offset" : _get_drag_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def drag_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Uses SmallArea Dimension."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_drag_area_metadata)

    _set_drag_area_metadata = { "offset" : _set_drag_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @drag_area.setter
    def drag_area(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_drag_area_metadata, value)

    _get_cr_metadata = { "offset" : _get_cr_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cr(self) -> float:
        """Get or set the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all. Dimensionless."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_cr_metadata)

    _set_cr_metadata = { "offset" : _set_cr_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cr.setter
    def cr(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_cr_metadata, value)

    _get_solar_radiation_pressure_area_metadata = { "offset" : _get_solar_radiation_pressure_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radiation_pressure_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Uses SmallArea Dimension."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_solar_radiation_pressure_area_metadata)

    _set_solar_radiation_pressure_area_metadata = { "offset" : _set_solar_radiation_pressure_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radiation_pressure_area.setter
    def solar_radiation_pressure_area(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_solar_radiation_pressure_area_metadata, value)

    _get_ck_metadata = { "offset" : _get_ck_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ck(self) -> float:
        """Get or set the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all. Dimensionless."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_ck_metadata)

    _set_ck_metadata = { "offset" : _set_ck_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @ck.setter
    def ck(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_ck_metadata, value)

    _get_radiation_pressure_area_metadata = { "offset" : _get_radiation_pressure_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radiation_pressure_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Uses SmallArea Dimension."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_radiation_pressure_area_metadata)

    _set_radiation_pressure_area_metadata = { "offset" : _set_radiation_pressure_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radiation_pressure_area.setter
    def radiation_pressure_area(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_radiation_pressure_area_metadata, value)

    _get_k1_metadata = { "offset" : _get_k1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k1(self) -> float:
        """If you are using a non-spherical SRP model, this field defines the model's GPS solar radiation pressure K1 (scale) value. Dimensionless."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_k1_metadata)

    _set_k1_metadata = { "offset" : _set_k1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k1.setter
    def k1(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_k1_metadata, value)

    _get_k2_metadata = { "offset" : _get_k2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k2(self) -> float:
        """If you are using a non-spherical SRP model, this field defines the model's GPS solar radiation pressure K2 (scale) value. Dimensionless."""
        return self._intf.get_property(SpacecraftParameters._metadata, SpacecraftParameters._get_k2_metadata)

    _set_k2_metadata = { "offset" : _set_k2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k2.setter
    def k2(self, value:float) -> None:
        return self._intf.set_property(SpacecraftParameters._metadata, SpacecraftParameters._set_k2_metadata, value)

    _property_names[dry_mass] = "dry_mass"
    _property_names[cd] = "cd"
    _property_names[drag_area] = "drag_area"
    _property_names[cr] = "cr"
    _property_names[solar_radiation_pressure_area] = "solar_radiation_pressure_area"
    _property_names[ck] = "ck"
    _property_names[radiation_pressure_area] = "radiation_pressure_area"
    _property_names[k1] = "k1"
    _property_names[k2] = "k2"

    def __init__(self, source_object=None):
        """Construct an object of type SpacecraftParameters."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SpacecraftParameters)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SpacecraftParameters, [SpacecraftParameters, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5397758463997765929, 8149019131139753100), SpacecraftParameters)
agcls.AgTypeNameMap["SpacecraftParameters"] = SpacecraftParameters

class FuelTank(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for fuel tank configuration."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_tank_pressure_method_offset = 1
    _set_tank_pressure_method_offset = 2
    _get_tank_volume_method_offset = 3
    _set_tank_volume_method_offset = 4
    _get_tank_temperature_method_offset = 5
    _set_tank_temperature_method_offset = 6
    _get_fuel_density_method_offset = 7
    _set_fuel_density_method_offset = 8
    _get_fuel_mass_method_offset = 9
    _set_fuel_mass_method_offset = 10
    _get_maximum_fuel_mass_method_offset = 11
    _set_maximum_fuel_mass_method_offset = 12
    _metadata = {
        "iid_data" : (5624502096774973488, 5173171893781027749),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FuelTank)

    _get_tank_pressure_metadata = { "offset" : _get_tank_pressure_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tank_pressure(self) -> float:
        """Get or set the fuel tank pressure. Uses Pressure Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_tank_pressure_metadata)

    _set_tank_pressure_metadata = { "offset" : _set_tank_pressure_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tank_pressure.setter
    def tank_pressure(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_tank_pressure_metadata, value)

    _get_tank_volume_metadata = { "offset" : _get_tank_volume_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tank_volume(self) -> float:
        """Get or set the volume of the fuel tank. Uses SmallVolume Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_tank_volume_metadata)

    _set_tank_volume_metadata = { "offset" : _set_tank_volume_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tank_volume.setter
    def tank_volume(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_tank_volume_metadata, value)

    _get_tank_temperature_metadata = { "offset" : _get_tank_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tank_temperature(self) -> float:
        """Get or set the temperature of the fuel tank. Uses Temperature Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_tank_temperature_metadata)

    _set_tank_temperature_metadata = { "offset" : _set_tank_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tank_temperature.setter
    def tank_temperature(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_tank_temperature_metadata, value)

    _get_fuel_density_metadata = { "offset" : _get_fuel_density_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_density(self) -> float:
        """Get or set the density of the fuel. Uses SmallDensity Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_fuel_density_metadata)

    _set_fuel_density_metadata = { "offset" : _set_fuel_density_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_density.setter
    def fuel_density(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_fuel_density_metadata, value)

    _get_fuel_mass_metadata = { "offset" : _get_fuel_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_mass(self) -> float:
        """Get or set the mass of the spacecraft propellant. Uses Mass Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_fuel_mass_metadata)

    _set_fuel_mass_metadata = { "offset" : _set_fuel_mass_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_mass.setter
    def fuel_mass(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_fuel_mass_metadata, value)

    _get_maximum_fuel_mass_metadata = { "offset" : _get_maximum_fuel_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maximum_fuel_mass(self) -> float:
        """Get or set the maximum fuel mass of the spacecraft; this parameter specifically applies to Finite Maneuver segments that are being executed in Backward Sequences. Uses Mass Dimension."""
        return self._intf.get_property(FuelTank._metadata, FuelTank._get_maximum_fuel_mass_metadata)

    _set_maximum_fuel_mass_metadata = { "offset" : _set_maximum_fuel_mass_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maximum_fuel_mass.setter
    def maximum_fuel_mass(self, value:float) -> None:
        return self._intf.set_property(FuelTank._metadata, FuelTank._set_maximum_fuel_mass_metadata, value)

    _property_names[tank_pressure] = "tank_pressure"
    _property_names[tank_volume] = "tank_volume"
    _property_names[tank_temperature] = "tank_temperature"
    _property_names[fuel_density] = "fuel_density"
    _property_names[fuel_mass] = "fuel_mass"
    _property_names[maximum_fuel_mass] = "maximum_fuel_mass"

    def __init__(self, source_object=None):
        """Construct an object of type FuelTank."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, FuelTank)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, FuelTank, [FuelTank, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5728765514206679012, 4259677341011527818), FuelTank)
agcls.AgTypeNameMap["FuelTank"] = FuelTank

class ElementCartesian(IElement, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for Cartesian elements."""

    _num_methods = 12
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_x_method_offset = 1
    _set_x_method_offset = 2
    _get_y_method_offset = 3
    _set_y_method_offset = 4
    _get_z_method_offset = 5
    _set_z_method_offset = 6
    _get_vx_method_offset = 7
    _set_vx_method_offset = 8
    _get_vy_method_offset = 9
    _set_vy_method_offset = 10
    _get_vz_method_offset = 11
    _set_vz_method_offset = 12
    _metadata = {
        "iid_data" : (5300421637043411044, 13353383975691849384),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementCartesian)

    _get_x_metadata = { "offset" : _get_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def x(self) -> float:
        """X position component. Uses Distance Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_x_metadata)

    _set_x_metadata = { "offset" : _set_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @x.setter
    def x(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_x_metadata, value)

    _get_y_metadata = { "offset" : _get_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y(self) -> float:
        """Y position component. Uses Distance Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_y_metadata)

    _set_y_metadata = { "offset" : _set_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y.setter
    def y(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_y_metadata, value)

    _get_z_metadata = { "offset" : _get_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def z(self) -> float:
        """Z position component. Uses Distance Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_z_metadata)

    _set_z_metadata = { "offset" : _set_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @z.setter
    def z(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_z_metadata, value)

    _get_vx_metadata = { "offset" : _get_vx_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def vx(self) -> float:
        """Vx velocity component. Uses Rate Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_vx_metadata)

    _set_vx_metadata = { "offset" : _set_vx_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @vx.setter
    def vx(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_vx_metadata, value)

    _get_vy_metadata = { "offset" : _get_vy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def vy(self) -> float:
        """Vy velocity component. Uses Rate Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_vy_metadata)

    _set_vy_metadata = { "offset" : _set_vy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @vy.setter
    def vy(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_vy_metadata, value)

    _get_vz_metadata = { "offset" : _get_vz_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def vz(self) -> float:
        """Vz velocity component. Uses Rate Dimension."""
        return self._intf.get_property(ElementCartesian._metadata, ElementCartesian._get_vz_metadata)

    _set_vz_metadata = { "offset" : _set_vz_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @vz.setter
    def vz(self, value:float) -> None:
        return self._intf.set_property(ElementCartesian._metadata, ElementCartesian._set_vz_metadata, value)

    _property_names[x] = "x"
    _property_names[y] = "y"
    _property_names[z] = "z"
    _property_names[vx] = "vx"
    _property_names[vy] = "vy"
    _property_names[vz] = "vz"

    def __init__(self, source_object=None):
        """Construct an object of type ElementCartesian."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementCartesian)
        IElement.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementCartesian, [ElementCartesian, IElement, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5499013447957353870, 11386343310021492869), ElementCartesian)
agcls.AgTypeNameMap["ElementCartesian"] = ElementCartesian

class ElementKeplerian(IElement, SupportsDeleteCallback):
    """Properties for Keplerian elements."""

    _num_methods = 46
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_semimajor_axis_method_offset = 1
    _set_semimajor_axis_method_offset = 2
    _get_eccentricity_method_offset = 3
    _set_eccentricity_method_offset = 4
    _get_inclination_method_offset = 5
    _set_inclination_method_offset = 6
    _get_raan_method_offset = 7
    _set_raan_method_offset = 8
    _get_arg_of_periapsis_method_offset = 9
    _set_arg_of_periapsis_method_offset = 10
    _get_true_anomaly_method_offset = 11
    _set_true_anomaly_method_offset = 12
    _get_apoapsis_altitude_size_method_offset = 13
    _set_apoapsis_altitude_size_method_offset = 14
    _get_apoapsis_radius_size_method_offset = 15
    _set_apoapsis_radius_size_method_offset = 16
    _get_mean_motion_method_offset = 17
    _set_mean_motion_method_offset = 18
    _get_periapsis_altitude_size_method_offset = 19
    _set_periapsis_altitude_size_method_offset = 20
    _get_periapsis_radius_size_method_offset = 21
    _set_periapsis_radius_size_method_offset = 22
    _get_period_method_offset = 23
    _set_period_method_offset = 24
    _get_lan_method_offset = 25
    _set_lan_method_offset = 26
    _get_arg_of_latitude_method_offset = 27
    _set_arg_of_latitude_method_offset = 28
    _get_eccentric_anomaly_method_offset = 29
    _set_eccentric_anomaly_method_offset = 30
    _get_mean_anomaly_method_offset = 31
    _set_mean_anomaly_method_offset = 32
    _get_time_past_ascending_node_method_offset = 33
    _set_time_past_ascending_node_method_offset = 34
    _get_time_past_periapsis_method_offset = 35
    _set_time_past_periapsis_method_offset = 36
    _get_element_type_method_offset = 37
    _set_element_type_method_offset = 38
    _get_apoapsis_altitude_shape_method_offset = 39
    _set_apoapsis_altitude_shape_method_offset = 40
    _get_apoapsis_radius_shape_method_offset = 41
    _set_apoapsis_radius_shape_method_offset = 42
    _get_periapsis_altitude_shape_method_offset = 43
    _set_periapsis_altitude_shape_method_offset = 44
    _get_periapsis_radius_shape_method_offset = 45
    _set_periapsis_radius_shape_method_offset = 46
    _metadata = {
        "iid_data" : (4838552578512971254, 14667696790538271421),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementKeplerian)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """One-half the distance along the long axis of the elliptical orbit. Uses Distance Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_semimajor_axis_metadata, value)

    _get_eccentricity_metadata = { "offset" : _get_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity(self) -> float:
        """Describes the shape of the ellipse (a real number >= 0 and <1, where 0 = a circular orbit). Dimensionless."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_eccentricity_metadata)

    _set_eccentricity_metadata = { "offset" : _set_eccentricity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @eccentricity.setter
    def eccentricity(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_eccentricity_metadata, value)

    _get_inclination_metadata = { "offset" : _get_inclination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inclination(self) -> typing.Any:
        """Get or set the angle between the angular momentum vector (perpendicular to the plane of the orbit) and the inertial Z axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_inclination_metadata)

    _set_inclination_metadata = { "offset" : _set_inclination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inclination.setter
    def inclination(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_inclination_metadata, value)

    _get_raan_metadata = { "offset" : _get_raan_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def raan(self) -> typing.Any:
        """Get or set the angle from the inertial X axis to the ascending node measured in a right-handed sense about the inertial Z axis in the equatorial plane. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_raan_metadata)

    _set_raan_metadata = { "offset" : _set_raan_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @raan.setter
    def raan(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_raan_metadata, value)

    _get_arg_of_periapsis_metadata = { "offset" : _get_arg_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def arg_of_periapsis(self) -> typing.Any:
        """Get or set the angle from the ascending node to the eccentricity vector (lowest point of orbit) measured in the direction of the satellite's motion and in the orbit plane. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_arg_of_periapsis_metadata)

    _set_arg_of_periapsis_metadata = { "offset" : _set_arg_of_periapsis_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @arg_of_periapsis.setter
    def arg_of_periapsis(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_arg_of_periapsis_metadata, value)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_anomaly(self) -> typing.Any:
        """Get or set the angle from the eccentricity vector (points toward perigee) to the satellite position vector, measured in the direction of satellite motion and in the orbit plane. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_true_anomaly_metadata)

    _set_true_anomaly_metadata = { "offset" : _set_true_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_anomaly.setter
    def true_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_true_anomaly_metadata, value)

    _get_apoapsis_altitude_size_metadata = { "offset" : _get_apoapsis_altitude_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def apoapsis_altitude_size(self) -> float:
        """Measured from the ``surface`` of the Earth to the points of maximum and minimum radius in the orbit. For these values, the surface of the Earth is modeled as a sphere whose radius equals the equatorial radius of the Earth. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_apoapsis_altitude_size_metadata)

    _set_apoapsis_altitude_size_metadata = { "offset" : _set_apoapsis_altitude_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @apoapsis_altitude_size.setter
    def apoapsis_altitude_size(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_apoapsis_altitude_size_metadata, value)

    _get_apoapsis_radius_size_metadata = { "offset" : _get_apoapsis_radius_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def apoapsis_radius_size(self) -> float:
        """Measured from the center of the Earth to the points of maximum and minimum radius in the orbit. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_apoapsis_radius_size_metadata)

    _set_apoapsis_radius_size_metadata = { "offset" : _set_apoapsis_radius_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @apoapsis_radius_size.setter
    def apoapsis_radius_size(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_apoapsis_radius_size_metadata, value)

    _get_mean_motion_metadata = { "offset" : _get_mean_motion_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_motion(self) -> float:
        """Get or set the uniform rate of the satellite in a circular orbit of the same period, typically expressed as degrees or radians per second, or as revolutions per day. Uses AngleRate dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_mean_motion_metadata)

    _set_mean_motion_metadata = { "offset" : _set_mean_motion_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_motion.setter
    def mean_motion(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_mean_motion_metadata, value)

    _get_periapsis_altitude_size_metadata = { "offset" : _get_periapsis_altitude_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def periapsis_altitude_size(self) -> float:
        """Measured from the ``surface`` of the Earth to the points of maximum and minimum radius in the orbit. For these values, the surface of the Earth is modeled as a sphere whose radius equals the equatorial radius of the Earth. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_periapsis_altitude_size_metadata)

    _set_periapsis_altitude_size_metadata = { "offset" : _set_periapsis_altitude_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @periapsis_altitude_size.setter
    def periapsis_altitude_size(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_periapsis_altitude_size_metadata, value)

    _get_periapsis_radius_size_metadata = { "offset" : _get_periapsis_radius_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def periapsis_radius_size(self) -> float:
        """Measured from the center of the Earth to the points of maximum and minimum radius in the orbit. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_periapsis_radius_size_metadata)

    _set_periapsis_radius_size_metadata = { "offset" : _set_periapsis_radius_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @periapsis_radius_size.setter
    def periapsis_radius_size(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_periapsis_radius_size_metadata, value)

    _get_period_metadata = { "offset" : _get_period_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def period(self) -> float:
        """Get or set the duration of one orbit, based on assumed two-body motion. Uses Time dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_period_metadata)

    _set_period_metadata = { "offset" : _set_period_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @period.setter
    def period(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_period_metadata, value)

    _get_lan_metadata = { "offset" : _get_lan_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lan(self) -> typing.Any:
        """Get or set the Earth-fixed longitude where the satellite has crossed the inertial equator (the intersection of the ground track and the inertial equator) from south to north based on an assumption of two-body motion. Uses Angle dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_lan_metadata)

    _set_lan_metadata = { "offset" : _set_lan_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lan.setter
    def lan(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_lan_metadata, value)

    _get_arg_of_latitude_metadata = { "offset" : _get_arg_of_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def arg_of_latitude(self) -> typing.Any:
        """Get or set the sum of the True Anomaly and the Argument of Perigee. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_arg_of_latitude_metadata)

    _set_arg_of_latitude_metadata = { "offset" : _set_arg_of_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @arg_of_latitude.setter
    def arg_of_latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_arg_of_latitude_metadata, value)

    _get_eccentric_anomaly_metadata = { "offset" : _get_eccentric_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def eccentric_anomaly(self) -> typing.Any:
        """Angle measured with origin at the center of the ellipse from the direction of perigee to a point on a circumscribing circle from which a line perpendicular to the SMA intersects the position of the satellite on the ellipse. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_eccentric_anomaly_metadata)

    _set_eccentric_anomaly_metadata = { "offset" : _set_eccentric_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @eccentric_anomaly.setter
    def eccentric_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_eccentric_anomaly_metadata, value)

    _get_mean_anomaly_metadata = { "offset" : _get_mean_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def mean_anomaly(self) -> typing.Any:
        """Get or set the angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate. Uses Angle Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_mean_anomaly_metadata)

    _set_mean_anomaly_metadata = { "offset" : _set_mean_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @mean_anomaly.setter
    def mean_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_mean_anomaly_metadata, value)

    _get_time_past_ascending_node_metadata = { "offset" : _get_time_past_ascending_node_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_past_ascending_node(self) -> float:
        """Get or set the elapsed time since the last ascending node crossing based on assumed two-body motion. Uses Time Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_time_past_ascending_node_metadata)

    _set_time_past_ascending_node_metadata = { "offset" : _set_time_past_ascending_node_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_past_ascending_node.setter
    def time_past_ascending_node(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_time_past_ascending_node_metadata, value)

    _get_time_past_periapsis_metadata = { "offset" : _get_time_past_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_past_periapsis(self) -> float:
        """Get or set the elapsed time since the last perigee passage based on assumed two-body motion. Uses Time Dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_time_past_periapsis_metadata)

    _set_time_past_periapsis_metadata = { "offset" : _set_time_past_periapsis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_past_periapsis.setter
    def time_past_periapsis(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_time_past_periapsis_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @property
    def element_type(self) -> "ElementType":
        """Which type of element (osculating or mean)."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @element_type.setter
    def element_type(self, value:"ElementType") -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_element_type_metadata, value)

    _get_apoapsis_altitude_shape_metadata = { "offset" : _get_apoapsis_altitude_shape_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def apoapsis_altitude_shape(self) -> float:
        """Describes the shape of the ellipse. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_apoapsis_altitude_shape_metadata)

    _set_apoapsis_altitude_shape_metadata = { "offset" : _set_apoapsis_altitude_shape_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @apoapsis_altitude_shape.setter
    def apoapsis_altitude_shape(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_apoapsis_altitude_shape_metadata, value)

    _get_apoapsis_radius_shape_metadata = { "offset" : _get_apoapsis_radius_shape_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def apoapsis_radius_shape(self) -> float:
        """Describes the shape of the ellipse. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_apoapsis_radius_shape_metadata)

    _set_apoapsis_radius_shape_metadata = { "offset" : _set_apoapsis_radius_shape_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @apoapsis_radius_shape.setter
    def apoapsis_radius_shape(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_apoapsis_radius_shape_metadata, value)

    _get_periapsis_altitude_shape_metadata = { "offset" : _get_periapsis_altitude_shape_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def periapsis_altitude_shape(self) -> float:
        """Describes the shape of the ellipse. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_periapsis_altitude_shape_metadata)

    _set_periapsis_altitude_shape_metadata = { "offset" : _set_periapsis_altitude_shape_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @periapsis_altitude_shape.setter
    def periapsis_altitude_shape(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_periapsis_altitude_shape_metadata, value)

    _get_periapsis_radius_shape_metadata = { "offset" : _get_periapsis_radius_shape_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def periapsis_radius_shape(self) -> float:
        """Describes the shape of the ellipse. Uses Distance dimension."""
        return self._intf.get_property(ElementKeplerian._metadata, ElementKeplerian._get_periapsis_radius_shape_metadata)

    _set_periapsis_radius_shape_metadata = { "offset" : _set_periapsis_radius_shape_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @periapsis_radius_shape.setter
    def periapsis_radius_shape(self, value:float) -> None:
        return self._intf.set_property(ElementKeplerian._metadata, ElementKeplerian._set_periapsis_radius_shape_metadata, value)

    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[eccentricity] = "eccentricity"
    _property_names[inclination] = "inclination"
    _property_names[raan] = "raan"
    _property_names[arg_of_periapsis] = "arg_of_periapsis"
    _property_names[true_anomaly] = "true_anomaly"
    _property_names[apoapsis_altitude_size] = "apoapsis_altitude_size"
    _property_names[apoapsis_radius_size] = "apoapsis_radius_size"
    _property_names[mean_motion] = "mean_motion"
    _property_names[periapsis_altitude_size] = "periapsis_altitude_size"
    _property_names[periapsis_radius_size] = "periapsis_radius_size"
    _property_names[period] = "period"
    _property_names[lan] = "lan"
    _property_names[arg_of_latitude] = "arg_of_latitude"
    _property_names[eccentric_anomaly] = "eccentric_anomaly"
    _property_names[mean_anomaly] = "mean_anomaly"
    _property_names[time_past_ascending_node] = "time_past_ascending_node"
    _property_names[time_past_periapsis] = "time_past_periapsis"
    _property_names[element_type] = "element_type"
    _property_names[apoapsis_altitude_shape] = "apoapsis_altitude_shape"
    _property_names[apoapsis_radius_shape] = "apoapsis_radius_shape"
    _property_names[periapsis_altitude_shape] = "periapsis_altitude_shape"
    _property_names[periapsis_radius_shape] = "periapsis_radius_shape"

    def __init__(self, source_object=None):
        """Construct an object of type ElementKeplerian."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementKeplerian)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementKeplerian, [ElementKeplerian, IElement])

agcls.AgClassCatalog.add_catalog_entry((4837397415885939909, 2998991674367307441), ElementKeplerian)
agcls.AgTypeNameMap["ElementKeplerian"] = ElementKeplerian

class ElementEquinoctial(IElement, SupportsDeleteCallback):
    """Properties for Equinoctial elements."""

    _num_methods = 16
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_semimajor_axis_method_offset = 1
    _set_semimajor_axis_method_offset = 2
    _get_mean_motion_method_offset = 3
    _set_mean_motion_method_offset = 4
    _get_h_method_offset = 5
    _set_h_method_offset = 6
    _get_k_method_offset = 7
    _set_k_method_offset = 8
    _get_p_method_offset = 9
    _set_p_method_offset = 10
    _get_q_method_offset = 11
    _set_q_method_offset = 12
    _get_mean_longitude_method_offset = 13
    _set_mean_longitude_method_offset = 14
    _get_formulation_method_offset = 15
    _set_formulation_method_offset = 16
    _metadata = {
        "iid_data" : (4929939837613149187, 12262545808188521122),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementEquinoctial)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """Half the length of the major axis of the orbital ellipse. Uses Distance Dimension."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_semimajor_axis_metadata, value)

    _get_mean_motion_metadata = { "offset" : _get_mean_motion_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_motion(self) -> float:
        """Get or set the average angular rate of the satellite based on 2 body motion. Uses Rate Dimension."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_mean_motion_metadata)

    _set_mean_motion_metadata = { "offset" : _set_mean_motion_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_motion.setter
    def mean_motion(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_mean_motion_metadata, value)

    _get_h_metadata = { "offset" : _get_h_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def h(self) -> float:
        """h/k collectively describe the shape of the satellite's orbit and the position of perigee. Dimensionless."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_h_metadata)

    _set_h_metadata = { "offset" : _set_h_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @h.setter
    def h(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_h_metadata, value)

    _get_k_metadata = { "offset" : _get_k_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k(self) -> float:
        """h/k collectively describe the shape of the satellite's orbit and the position of perigee. Dimensionless."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_k_metadata)

    _set_k_metadata = { "offset" : _set_k_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k.setter
    def k(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_k_metadata, value)

    _get_p_metadata = { "offset" : _get_p_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def p(self) -> float:
        """p/q collectively describe the orientation of the satellite's orbit plane. Dimensionless."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_p_metadata)

    _set_p_metadata = { "offset" : _set_p_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @p.setter
    def p(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_p_metadata, value)

    _get_q_metadata = { "offset" : _get_q_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def q(self) -> float:
        """p/q collectively describe the orientation of the satellite's orbit plane. Dimensionless."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_q_metadata)

    _set_q_metadata = { "offset" : _set_q_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @q.setter
    def q(self, value:float) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_q_metadata, value)

    _get_mean_longitude_metadata = { "offset" : _get_mean_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def mean_longitude(self) -> typing.Any:
        """Specify a satellite's position within its orbit at epoch and equals the sum of the classical Right Ascension of the Ascending Node, Argument of Perigee, and Mean Anomaly. Uses Angle Dimension."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_mean_longitude_metadata)

    _set_mean_longitude_metadata = { "offset" : _set_mean_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @mean_longitude.setter
    def mean_longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_mean_longitude_metadata, value)

    _get_formulation_metadata = { "offset" : _get_formulation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Formulation),) }
    @property
    def formulation(self) -> "Formulation":
        """Retrograde, which has its singularity at an inclination of 0 deg. Posigrade, which has its singularity at an inclination of 180 deg."""
        return self._intf.get_property(ElementEquinoctial._metadata, ElementEquinoctial._get_formulation_metadata)

    _set_formulation_metadata = { "offset" : _set_formulation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Formulation),) }
    @formulation.setter
    def formulation(self, value:"Formulation") -> None:
        return self._intf.set_property(ElementEquinoctial._metadata, ElementEquinoctial._set_formulation_metadata, value)

    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[mean_motion] = "mean_motion"
    _property_names[h] = "h"
    _property_names[k] = "k"
    _property_names[p] = "p"
    _property_names[q] = "q"
    _property_names[mean_longitude] = "mean_longitude"
    _property_names[formulation] = "formulation"

    def __init__(self, source_object=None):
        """Construct an object of type ElementEquinoctial."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementEquinoctial)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementEquinoctial, [ElementEquinoctial, IElement])

agcls.AgClassCatalog.add_catalog_entry((4616647420053820287, 5121823230219393442), ElementEquinoctial)
agcls.AgTypeNameMap["ElementEquinoctial"] = ElementEquinoctial

class ElementDelaunay(IElement, SupportsDeleteCallback):
    """Properties for Delaunay elements."""

    _num_methods = 18
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_mean_anomaly_method_offset = 1
    _set_mean_anomaly_method_offset = 2
    _get_arg_of_periapsis_method_offset = 3
    _set_arg_of_periapsis_method_offset = 4
    _get_raan_method_offset = 5
    _set_raan_method_offset = 6
    _get_delaunay_l_method_offset = 7
    _set_delaunay_l_method_offset = 8
    _get_semimajor_axis_method_offset = 9
    _set_semimajor_axis_method_offset = 10
    _get_delaunay_g_method_offset = 11
    _set_delaunay_g_method_offset = 12
    _get_semilatus_rectum_method_offset = 13
    _set_semilatus_rectum_method_offset = 14
    _get_delaunay_h_method_offset = 15
    _set_delaunay_h_method_offset = 16
    _get_inclination_method_offset = 17
    _set_inclination_method_offset = 18
    _metadata = {
        "iid_data" : (4889723355609554180, 2305371170781207216),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementDelaunay)

    _get_mean_anomaly_metadata = { "offset" : _get_mean_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def mean_anomaly(self) -> typing.Any:
        """Get or set the angle from the eccentricity vector to a position vector where the satellite would be if it were always moving at its average angular rate (l). Uses Angle Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_mean_anomaly_metadata)

    _set_mean_anomaly_metadata = { "offset" : _set_mean_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @mean_anomaly.setter
    def mean_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_mean_anomaly_metadata, value)

    _get_arg_of_periapsis_metadata = { "offset" : _get_arg_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def arg_of_periapsis(self) -> typing.Any:
        """Get or set the angle from the ascending node to the eccentricity vector (lowest point of orbit) measured in the direction of the satellite's motion and in the orbit plane (g). Uses Angle Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_arg_of_periapsis_metadata)

    _set_arg_of_periapsis_metadata = { "offset" : _set_arg_of_periapsis_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @arg_of_periapsis.setter
    def arg_of_periapsis(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_arg_of_periapsis_metadata, value)

    _get_raan_metadata = { "offset" : _get_raan_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def raan(self) -> typing.Any:
        """Get or set the angle from the inertial X axis to the ascending node measured in a right-handed sense about the inertial Z axis in the equatorial plane (h). Uses Angle Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_raan_metadata)

    _set_raan_metadata = { "offset" : _set_raan_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @raan.setter
    def raan(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_raan_metadata, value)

    _get_delaunay_l_metadata = { "offset" : _get_delaunay_l_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delaunay_l(self) -> float:
        """Related to the two-body orbital energy. Defined as sqrt(GM * a).   Uses AreaRate Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_delaunay_l_metadata)

    _set_delaunay_l_metadata = { "offset" : _set_delaunay_l_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delaunay_l.setter
    def delaunay_l(self, value:float) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_delaunay_l_metadata, value)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """One-half the distance along the long axis of the elliptical orbit. Uses Distance Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_semimajor_axis_metadata, value)

    _get_delaunay_g_metadata = { "offset" : _get_delaunay_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delaunay_g(self) -> float:
        """Get or set the magnitude of the orbital angular momentum. Defined as sqrt(GM * p). Uses AreaRate Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_delaunay_g_metadata)

    _set_delaunay_g_metadata = { "offset" : _set_delaunay_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delaunay_g.setter
    def delaunay_g(self, value:float) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_delaunay_g_metadata, value)

    _get_semilatus_rectum_metadata = { "offset" : _get_semilatus_rectum_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semilatus_rectum(self) -> float:
        """Semi-latus Rectum. Uses Distance Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_semilatus_rectum_metadata)

    _set_semilatus_rectum_metadata = { "offset" : _set_semilatus_rectum_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semilatus_rectum.setter
    def semilatus_rectum(self, value:float) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_semilatus_rectum_metadata, value)

    _get_delaunay_h_metadata = { "offset" : _get_delaunay_h_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delaunay_h(self) -> float:
        """Get or set the Z component of the orbital angular momentum. Defined as G cos(inc).  Uses AreaRate Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_delaunay_h_metadata)

    _set_delaunay_h_metadata = { "offset" : _set_delaunay_h_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delaunay_h.setter
    def delaunay_h(self, value:float) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_delaunay_h_metadata, value)

    _get_inclination_metadata = { "offset" : _get_inclination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inclination(self) -> typing.Any:
        """Get or set the angle between the angular momentum vector (perpendicular to the plane of the orbit) and the inertial Z axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementDelaunay._metadata, ElementDelaunay._get_inclination_metadata)

    _set_inclination_metadata = { "offset" : _set_inclination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inclination.setter
    def inclination(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementDelaunay._metadata, ElementDelaunay._set_inclination_metadata, value)

    _property_names[mean_anomaly] = "mean_anomaly"
    _property_names[arg_of_periapsis] = "arg_of_periapsis"
    _property_names[raan] = "raan"
    _property_names[delaunay_l] = "delaunay_l"
    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[delaunay_g] = "delaunay_g"
    _property_names[semilatus_rectum] = "semilatus_rectum"
    _property_names[delaunay_h] = "delaunay_h"
    _property_names[inclination] = "inclination"

    def __init__(self, source_object=None):
        """Construct an object of type ElementDelaunay."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementDelaunay)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementDelaunay, [ElementDelaunay, IElement])

agcls.AgClassCatalog.add_catalog_entry((5235483572359958962, 10845894774806134964), ElementDelaunay)
agcls.AgTypeNameMap["ElementDelaunay"] = ElementDelaunay

class ElementMixedSpherical(IElement, SupportsDeleteCallback):
    """Properties for Mixed Spherical elements."""

    _num_methods = 14
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_longitude_method_offset = 1
    _set_longitude_method_offset = 2
    _get_latitude_method_offset = 3
    _set_latitude_method_offset = 4
    _get_altitude_method_offset = 5
    _set_altitude_method_offset = 6
    _get_horizontal_flight_path_angle_method_offset = 7
    _set_horizontal_flight_path_angle_method_offset = 8
    _get_velocity_azimuth_method_offset = 9
    _set_velocity_azimuth_method_offset = 10
    _get_velocity_magnitude_method_offset = 11
    _set_velocity_magnitude_method_offset = 12
    _get_vertical_flight_path_angle_method_offset = 13
    _set_vertical_flight_path_angle_method_offset = 14
    _metadata = {
        "iid_data" : (5321102592411773457, 10534508528245466780),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementMixedSpherical)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Measured from -180.0 deg to +360.0 deg. Uses Angle Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_longitude_metadata, value)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Measured from -90.0 deg to +90.0 deg. The geodetic latitude of a point is the angle between (1) the normal to the reference ellipsoid that passes through the satellite position and (2) the equatorial plane. Uses Angle Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_latitude_metadata, value)

    _get_altitude_metadata = { "offset" : _get_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude(self) -> float:
        """Get or set the object's position above or below the reference ellipsoid. Altitude is measured along a normal to the surface of the reference ellipsoid. Uses Distance Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_altitude_metadata)

    _set_altitude_metadata = { "offset" : _set_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude.setter
    def altitude(self, value:float) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_altitude_metadata, value)

    _get_horizontal_flight_path_angle_metadata = { "offset" : _get_horizontal_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def horizontal_flight_path_angle(self) -> typing.Any:
        """Horizontal (Hor FPA) or vertical (Ver FPA) flight path angle. The angle between the inertial velocity vector and the radius vector (vertical) or the complement of this angle (horizontal). Uses Angle Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_horizontal_flight_path_angle_metadata)

    _set_horizontal_flight_path_angle_metadata = { "offset" : _set_horizontal_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @horizontal_flight_path_angle.setter
    def horizontal_flight_path_angle(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_horizontal_flight_path_angle_metadata, value)

    _get_velocity_azimuth_metadata = { "offset" : _get_velocity_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def velocity_azimuth(self) -> typing.Any:
        """Get or set the angle in the satellite local horizontal plane between the projection of the inertial velocity vector onto this plane and the local north direction measured as positive in the clockwise direction. Uses Angle Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_velocity_azimuth_metadata)

    _set_velocity_azimuth_metadata = { "offset" : _set_velocity_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @velocity_azimuth.setter
    def velocity_azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_velocity_azimuth_metadata, value)

    _get_velocity_magnitude_metadata = { "offset" : _get_velocity_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_magnitude(self) -> float:
        """Get or set the angle in the satellite local horizontal plane between the projection of the inertial velocity vector onto this plane and the local north direction measured as positive in the clockwise direction. Uses Rate Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_velocity_magnitude_metadata)

    _set_velocity_magnitude_metadata = { "offset" : _set_velocity_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @velocity_magnitude.setter
    def velocity_magnitude(self, value:float) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_velocity_magnitude_metadata, value)

    _get_vertical_flight_path_angle_metadata = { "offset" : _get_vertical_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def vertical_flight_path_angle(self) -> typing.Any:
        """Horizontal (Hor FPA) or vertical (Ver FPA) flight path angle. The angle between the inertial velocity vector and the radius vector (vertical) or the complement of this angle (horizontal). Uses Angle Dimension."""
        return self._intf.get_property(ElementMixedSpherical._metadata, ElementMixedSpherical._get_vertical_flight_path_angle_metadata)

    _set_vertical_flight_path_angle_metadata = { "offset" : _set_vertical_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @vertical_flight_path_angle.setter
    def vertical_flight_path_angle(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementMixedSpherical._metadata, ElementMixedSpherical._set_vertical_flight_path_angle_metadata, value)

    _property_names[longitude] = "longitude"
    _property_names[latitude] = "latitude"
    _property_names[altitude] = "altitude"
    _property_names[horizontal_flight_path_angle] = "horizontal_flight_path_angle"
    _property_names[velocity_azimuth] = "velocity_azimuth"
    _property_names[velocity_magnitude] = "velocity_magnitude"
    _property_names[vertical_flight_path_angle] = "vertical_flight_path_angle"

    def __init__(self, source_object=None):
        """Construct an object of type ElementMixedSpherical."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementMixedSpherical)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementMixedSpherical, [ElementMixedSpherical, IElement])

agcls.AgClassCatalog.add_catalog_entry((5073171977022283093, 17307231198305551532), ElementMixedSpherical)
agcls.AgTypeNameMap["ElementMixedSpherical"] = ElementMixedSpherical

class ElementSpherical(IElement, SupportsDeleteCallback):
    """Properties for Spherical elements."""

    _num_methods = 14
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_right_ascension_method_offset = 1
    _set_right_ascension_method_offset = 2
    _get_declination_method_offset = 3
    _set_declination_method_offset = 4
    _get_radius_magnitude_method_offset = 5
    _set_radius_magnitude_method_offset = 6
    _get_horizontal_flight_path_angle_method_offset = 7
    _set_horizontal_flight_path_angle_method_offset = 8
    _get_velocity_azimuth_method_offset = 9
    _set_velocity_azimuth_method_offset = 10
    _get_velocity_magnitude_method_offset = 11
    _set_velocity_magnitude_method_offset = 12
    _get_vertical_flight_path_angle_method_offset = 13
    _set_vertical_flight_path_angle_method_offset = 14
    _metadata = {
        "iid_data" : (5756098792360695636, 8434394741165502088),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementSpherical)

    _get_right_ascension_metadata = { "offset" : _get_right_ascension_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def right_ascension(self) -> typing.Any:
        """Defined as the angle from the X axis to the projection of the satellite position vector in the equatorial plane measured as positive in the direction of the Y axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_right_ascension_metadata)

    _set_right_ascension_metadata = { "offset" : _set_right_ascension_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @right_ascension.setter
    def right_ascension(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_right_ascension_metadata, value)

    _get_declination_metadata = { "offset" : _get_declination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def declination(self) -> typing.Any:
        """Defined as the angle between the satellite position vector and the inertial equatorial plane measured as positive toward the positive inertial Z axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_declination_metadata)

    _set_declination_metadata = { "offset" : _set_declination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @declination.setter
    def declination(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_declination_metadata, value)

    _get_radius_magnitude_metadata = { "offset" : _get_radius_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_magnitude(self) -> float:
        """Get or set the magnitude of the satellite position vector. Uses Distance Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_radius_magnitude_metadata)

    _set_radius_magnitude_metadata = { "offset" : _set_radius_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_magnitude.setter
    def radius_magnitude(self, value:float) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_radius_magnitude_metadata, value)

    _get_horizontal_flight_path_angle_metadata = { "offset" : _get_horizontal_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def horizontal_flight_path_angle(self) -> typing.Any:
        """Horizontal (Hor FPA) or vertical (Ver FPA) flight path angle. The angle between the velocity vector and the radius vector (vertical) or the complement of this angle (horizontal). Uses Angle Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_horizontal_flight_path_angle_metadata)

    _set_horizontal_flight_path_angle_metadata = { "offset" : _set_horizontal_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @horizontal_flight_path_angle.setter
    def horizontal_flight_path_angle(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_horizontal_flight_path_angle_metadata, value)

    _get_velocity_azimuth_metadata = { "offset" : _get_velocity_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def velocity_azimuth(self) -> typing.Any:
        """Get or set the angle in the satellite local horizontal plane between the projection of the velocity vector onto this plane and the local north direction measured as positive in the clockwise direction. Uses Angle Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_velocity_azimuth_metadata)

    _set_velocity_azimuth_metadata = { "offset" : _set_velocity_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @velocity_azimuth.setter
    def velocity_azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_velocity_azimuth_metadata, value)

    _get_velocity_magnitude_metadata = { "offset" : _get_velocity_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_magnitude(self) -> float:
        """Get or set the magnitude of the velocity vector. Uses Rate Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_velocity_magnitude_metadata)

    _set_velocity_magnitude_metadata = { "offset" : _set_velocity_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @velocity_magnitude.setter
    def velocity_magnitude(self, value:float) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_velocity_magnitude_metadata, value)

    _get_vertical_flight_path_angle_metadata = { "offset" : _get_vertical_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def vertical_flight_path_angle(self) -> typing.Any:
        """Horizontal (Hor FPA) or vertical (Ver FPA) flight path angle. The angle between the velocity vector and the radius vector (vertical) or the complement of this angle (horizontal). Uses Angle Dimension."""
        return self._intf.get_property(ElementSpherical._metadata, ElementSpherical._get_vertical_flight_path_angle_metadata)

    _set_vertical_flight_path_angle_metadata = { "offset" : _set_vertical_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @vertical_flight_path_angle.setter
    def vertical_flight_path_angle(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSpherical._metadata, ElementSpherical._set_vertical_flight_path_angle_metadata, value)

    _property_names[right_ascension] = "right_ascension"
    _property_names[declination] = "declination"
    _property_names[radius_magnitude] = "radius_magnitude"
    _property_names[horizontal_flight_path_angle] = "horizontal_flight_path_angle"
    _property_names[velocity_azimuth] = "velocity_azimuth"
    _property_names[velocity_magnitude] = "velocity_magnitude"
    _property_names[vertical_flight_path_angle] = "vertical_flight_path_angle"

    def __init__(self, source_object=None):
        """Construct an object of type ElementSpherical."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementSpherical)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementSpherical, [ElementSpherical, IElement])

agcls.AgClassCatalog.add_catalog_entry((5178479078200941926, 400212392703168189), ElementSpherical)
agcls.AgTypeNameMap["ElementSpherical"] = ElementSpherical

class ElementTargetVectorIncomingAsymptote(IElement, SupportsDeleteCallback):
    """Properties for Target Vector Incoming Asymptote elements."""

    _num_methods = 12
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_radius_of_periapsis_method_offset = 1
    _set_radius_of_periapsis_method_offset = 2
    _get_c3_energy_method_offset = 3
    _set_c3_energy_method_offset = 4
    _get_right_ascension_of_incoming_asymptote_method_offset = 5
    _set_right_ascension_of_incoming_asymptote_method_offset = 6
    _get_declination_of_incoming_asymptote_method_offset = 7
    _set_declination_of_incoming_asymptote_method_offset = 8
    _get_velocity_azimuth_periapsis_method_offset = 9
    _set_velocity_azimuth_periapsis_method_offset = 10
    _get_true_anomaly_method_offset = 11
    _set_true_anomaly_method_offset = 12
    _metadata = {
        "iid_data" : (4892995040687317426, 11752684495085238196),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementTargetVectorIncomingAsymptote)

    _get_radius_of_periapsis_metadata = { "offset" : _get_radius_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_of_periapsis(self) -> float:
        """Radius of Periapsis. Uses Distance Dimension."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_radius_of_periapsis_metadata)

    _set_radius_of_periapsis_metadata = { "offset" : _set_radius_of_periapsis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_of_periapsis.setter
    def radius_of_periapsis(self, value:float) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_radius_of_periapsis_metadata, value)

    _get_c3_energy_metadata = { "offset" : _get_c3_energy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c3_energy(self) -> float:
        """C3Energy (Rate squared)."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_c3_energy_metadata)

    _set_c3_energy_metadata = { "offset" : _set_c3_energy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c3_energy.setter
    def c3_energy(self, value:float) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_c3_energy_metadata, value)

    _get_right_ascension_of_incoming_asymptote_metadata = { "offset" : _get_right_ascension_of_incoming_asymptote_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def right_ascension_of_incoming_asymptote(self) -> typing.Any:
        """Right Ascension of Incoming Asymptote. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_right_ascension_of_incoming_asymptote_metadata)

    _set_right_ascension_of_incoming_asymptote_metadata = { "offset" : _set_right_ascension_of_incoming_asymptote_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @right_ascension_of_incoming_asymptote.setter
    def right_ascension_of_incoming_asymptote(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_right_ascension_of_incoming_asymptote_metadata, value)

    _get_declination_of_incoming_asymptote_metadata = { "offset" : _get_declination_of_incoming_asymptote_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def declination_of_incoming_asymptote(self) -> typing.Any:
        """Declination of Incoming Asymptote. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_declination_of_incoming_asymptote_metadata)

    _set_declination_of_incoming_asymptote_metadata = { "offset" : _set_declination_of_incoming_asymptote_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @declination_of_incoming_asymptote.setter
    def declination_of_incoming_asymptote(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_declination_of_incoming_asymptote_metadata, value)

    _get_velocity_azimuth_periapsis_metadata = { "offset" : _get_velocity_azimuth_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def velocity_azimuth_periapsis(self) -> typing.Any:
        """Velocity Azimuth at Periapsis. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_velocity_azimuth_periapsis_metadata)

    _set_velocity_azimuth_periapsis_metadata = { "offset" : _set_velocity_azimuth_periapsis_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @velocity_azimuth_periapsis.setter
    def velocity_azimuth_periapsis(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_velocity_azimuth_periapsis_metadata, value)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_anomaly(self) -> typing.Any:
        """True Anomaly. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._get_true_anomaly_metadata)

    _set_true_anomaly_metadata = { "offset" : _set_true_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_anomaly.setter
    def true_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorIncomingAsymptote._metadata, ElementTargetVectorIncomingAsymptote._set_true_anomaly_metadata, value)

    _property_names[radius_of_periapsis] = "radius_of_periapsis"
    _property_names[c3_energy] = "c3_energy"
    _property_names[right_ascension_of_incoming_asymptote] = "right_ascension_of_incoming_asymptote"
    _property_names[declination_of_incoming_asymptote] = "declination_of_incoming_asymptote"
    _property_names[velocity_azimuth_periapsis] = "velocity_azimuth_periapsis"
    _property_names[true_anomaly] = "true_anomaly"

    def __init__(self, source_object=None):
        """Construct an object of type ElementTargetVectorIncomingAsymptote."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementTargetVectorIncomingAsymptote)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementTargetVectorIncomingAsymptote, [ElementTargetVectorIncomingAsymptote, IElement])

agcls.AgClassCatalog.add_catalog_entry((4791707063847479912, 8451572865872127390), ElementTargetVectorIncomingAsymptote)
agcls.AgTypeNameMap["ElementTargetVectorIncomingAsymptote"] = ElementTargetVectorIncomingAsymptote

class ElementTargetVectorOutgoingAsymptote(IElement, SupportsDeleteCallback):
    """Properties for Target Vector Outgoing Asymptote elements."""

    _num_methods = 12
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_radius_of_periapsis_method_offset = 1
    _set_radius_of_periapsis_method_offset = 2
    _get_c3_energy_method_offset = 3
    _set_c3_energy_method_offset = 4
    _get_right_ascension_of_outgoing_asymptote_method_offset = 5
    _set_right_ascension_of_outgoing_asymptote_method_offset = 6
    _get_declination_of_outgoing_asymptote_method_offset = 7
    _set_declination_of_outgoing_asymptote_method_offset = 8
    _get_velocity_azimuth_periapsis_method_offset = 9
    _set_velocity_azimuth_periapsis_method_offset = 10
    _get_true_anomaly_method_offset = 11
    _set_true_anomaly_method_offset = 12
    _metadata = {
        "iid_data" : (5339488085564360630, 8608472543383636129),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementTargetVectorOutgoingAsymptote)

    _get_radius_of_periapsis_metadata = { "offset" : _get_radius_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_of_periapsis(self) -> float:
        """Radius of Periapsis. Uses Distance Dimension."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_radius_of_periapsis_metadata)

    _set_radius_of_periapsis_metadata = { "offset" : _set_radius_of_periapsis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_of_periapsis.setter
    def radius_of_periapsis(self, value:float) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_radius_of_periapsis_metadata, value)

    _get_c3_energy_metadata = { "offset" : _get_c3_energy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c3_energy(self) -> float:
        """C3Energy (Rate Squared)."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_c3_energy_metadata)

    _set_c3_energy_metadata = { "offset" : _set_c3_energy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c3_energy.setter
    def c3_energy(self, value:float) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_c3_energy_metadata, value)

    _get_right_ascension_of_outgoing_asymptote_metadata = { "offset" : _get_right_ascension_of_outgoing_asymptote_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def right_ascension_of_outgoing_asymptote(self) -> typing.Any:
        """Right Ascension of Incoming Asymptote. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_right_ascension_of_outgoing_asymptote_metadata)

    _set_right_ascension_of_outgoing_asymptote_metadata = { "offset" : _set_right_ascension_of_outgoing_asymptote_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @right_ascension_of_outgoing_asymptote.setter
    def right_ascension_of_outgoing_asymptote(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_right_ascension_of_outgoing_asymptote_metadata, value)

    _get_declination_of_outgoing_asymptote_metadata = { "offset" : _get_declination_of_outgoing_asymptote_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def declination_of_outgoing_asymptote(self) -> typing.Any:
        """Declination of Incoming Asymptote. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_declination_of_outgoing_asymptote_metadata)

    _set_declination_of_outgoing_asymptote_metadata = { "offset" : _set_declination_of_outgoing_asymptote_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @declination_of_outgoing_asymptote.setter
    def declination_of_outgoing_asymptote(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_declination_of_outgoing_asymptote_metadata, value)

    _get_velocity_azimuth_periapsis_metadata = { "offset" : _get_velocity_azimuth_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def velocity_azimuth_periapsis(self) -> typing.Any:
        """Velocity Azimuth at Periapsis. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_velocity_azimuth_periapsis_metadata)

    _set_velocity_azimuth_periapsis_metadata = { "offset" : _set_velocity_azimuth_periapsis_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @velocity_azimuth_periapsis.setter
    def velocity_azimuth_periapsis(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_velocity_azimuth_periapsis_metadata, value)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_anomaly(self) -> typing.Any:
        """True Anomaly. Uses Angle Dimension."""
        return self._intf.get_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._get_true_anomaly_metadata)

    _set_true_anomaly_metadata = { "offset" : _set_true_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_anomaly.setter
    def true_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementTargetVectorOutgoingAsymptote._metadata, ElementTargetVectorOutgoingAsymptote._set_true_anomaly_metadata, value)

    _property_names[radius_of_periapsis] = "radius_of_periapsis"
    _property_names[c3_energy] = "c3_energy"
    _property_names[right_ascension_of_outgoing_asymptote] = "right_ascension_of_outgoing_asymptote"
    _property_names[declination_of_outgoing_asymptote] = "declination_of_outgoing_asymptote"
    _property_names[velocity_azimuth_periapsis] = "velocity_azimuth_periapsis"
    _property_names[true_anomaly] = "true_anomaly"

    def __init__(self, source_object=None):
        """Construct an object of type ElementTargetVectorOutgoingAsymptote."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementTargetVectorOutgoingAsymptote)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementTargetVectorOutgoingAsymptote, [ElementTargetVectorOutgoingAsymptote, IElement])

agcls.AgClassCatalog.add_catalog_entry((5739406173576252558, 18013377322023481482), ElementTargetVectorOutgoingAsymptote)
agcls.AgTypeNameMap["ElementTargetVectorOutgoingAsymptote"] = ElementTargetVectorOutgoingAsymptote

class ElementGeodetic(IElement, SupportsDeleteCallback):
    """Properties for Geodetic elements."""

    _num_methods = 16
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_altitude_method_offset = 5
    _set_altitude_method_offset = 6
    _get_radius_magnitude_method_offset = 7
    _set_radius_magnitude_method_offset = 8
    _get_latitude_rate_method_offset = 9
    _set_latitude_rate_method_offset = 10
    _get_longitude_rate_method_offset = 11
    _set_longitude_rate_method_offset = 12
    _get_altitude_rate_method_offset = 13
    _set_altitude_rate_method_offset = 14
    _get_radius_rate_method_offset = 15
    _set_radius_rate_method_offset = 16
    _metadata = {
        "iid_data" : (5001084873375430510, 1131906645414183102),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementGeodetic)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Measured in degrees from -90.0 deg to +90.0 deg. The geodetic latitude of a point is the angle between the normal to the reference ellipsoid and the equatorial plane. Uses Angle Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Measured in degrees from -360.0 deg to +360.0 deg. The longitude of a point is the angle between the projection of the position vector in the equatorial plane and the prime meridian. Uses Angle Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_longitude_metadata, value)

    _get_altitude_metadata = { "offset" : _get_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude(self) -> float:
        """Measured along an outward normal to the surface of the ellipsoid. Uses Distance Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_altitude_metadata)

    _set_altitude_metadata = { "offset" : _set_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude.setter
    def altitude(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_altitude_metadata, value)

    _get_radius_magnitude_metadata = { "offset" : _get_radius_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_magnitude(self) -> float:
        """Measured from the center of the Earth. Specified as distance above or below the reference ellipsoid. Uses Distance Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_radius_magnitude_metadata)

    _set_radius_magnitude_metadata = { "offset" : _set_radius_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_magnitude.setter
    def radius_magnitude(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_radius_magnitude_metadata, value)

    _get_latitude_rate_metadata = { "offset" : _get_latitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def latitude_rate(self) -> float:
        """Get or set the rate of change of the satellite's latitude. Uses Rate Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_latitude_rate_metadata)

    _set_latitude_rate_metadata = { "offset" : _set_latitude_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @latitude_rate.setter
    def latitude_rate(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_latitude_rate_metadata, value)

    _get_longitude_rate_metadata = { "offset" : _get_longitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def longitude_rate(self) -> float:
        """Get or set the rate of change of the satellite's longitude. Uses Rate Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_longitude_rate_metadata)

    _set_longitude_rate_metadata = { "offset" : _set_longitude_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @longitude_rate.setter
    def longitude_rate(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_longitude_rate_metadata, value)

    _get_altitude_rate_metadata = { "offset" : _get_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_rate(self) -> float:
        """Get or set the rate of change of the altitude. Uses Rate Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_altitude_rate_metadata)

    _set_altitude_rate_metadata = { "offset" : _set_altitude_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_rate.setter
    def altitude_rate(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_altitude_rate_metadata, value)

    _get_radius_rate_metadata = { "offset" : _get_radius_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_rate(self) -> float:
        """Get or set the rate of change of the radius. Uses Rate Dimension."""
        return self._intf.get_property(ElementGeodetic._metadata, ElementGeodetic._get_radius_rate_metadata)

    _set_radius_rate_metadata = { "offset" : _set_radius_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_rate.setter
    def radius_rate(self, value:float) -> None:
        return self._intf.set_property(ElementGeodetic._metadata, ElementGeodetic._set_radius_rate_metadata, value)

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[altitude] = "altitude"
    _property_names[radius_magnitude] = "radius_magnitude"
    _property_names[latitude_rate] = "latitude_rate"
    _property_names[longitude_rate] = "longitude_rate"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[radius_rate] = "radius_rate"

    def __init__(self, source_object=None):
        """Construct an object of type ElementGeodetic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementGeodetic)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementGeodetic, [ElementGeodetic, IElement])

agcls.AgClassCatalog.add_catalog_entry((4649398427299663878, 376586418108698241), ElementGeodetic)
agcls.AgTypeNameMap["ElementGeodetic"] = ElementGeodetic

class ElementBPlane(IElement, SupportsDeleteCallback):
    """Properties for BPlane elements."""

    _num_methods = 26
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_right_ascension_of_b_plane_method_offset = 1
    _set_right_ascension_of_b_plane_method_offset = 2
    _get_declination_of_b_plane_method_offset = 3
    _set_declination_of_b_plane_method_offset = 4
    _get_b_dot_r_first_b_vector_method_offset = 5
    _set_b_dot_r_first_b_vector_method_offset = 6
    _get_b_dot_t_second_b_vector_method_offset = 7
    _set_b_dot_t_second_b_vector_method_offset = 8
    _get_hyperbolic_turning_angle_method_offset = 9
    _set_hyperbolic_turning_angle_method_offset = 10
    _get_orbital_c3_energy_method_offset = 11
    _set_orbital_c3_energy_method_offset = 12
    _get_hyperbolic_v_infinity_method_offset = 13
    _set_hyperbolic_v_infinity_method_offset = 14
    _get_semimajor_axis_method_offset = 15
    _set_semimajor_axis_method_offset = 16
    _get_b_dot_t_first_b_vector_method_offset = 17
    _set_b_dot_t_first_b_vector_method_offset = 18
    _get_b_theta_first_b_vector_method_offset = 19
    _set_b_theta_first_b_vector_method_offset = 20
    _get_b_dot_r_second_b_vector_method_offset = 21
    _set_b_dot_r_second_b_vector_method_offset = 22
    _get_b_magnitude_second_b_vector_method_offset = 23
    _set_b_magnitude_second_b_vector_method_offset = 24
    _get_true_anomaly_method_offset = 25
    _set_true_anomaly_method_offset = 26
    _metadata = {
        "iid_data" : (5408340847027096584, 1882909674586958218),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementBPlane)

    _get_right_ascension_of_b_plane_metadata = { "offset" : _get_right_ascension_of_b_plane_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def right_ascension_of_b_plane(self) -> float:
        """Right Ascension of the B-Plane Normal."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_right_ascension_of_b_plane_metadata)

    _set_right_ascension_of_b_plane_metadata = { "offset" : _set_right_ascension_of_b_plane_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @right_ascension_of_b_plane.setter
    def right_ascension_of_b_plane(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_right_ascension_of_b_plane_metadata, value)

    _get_declination_of_b_plane_metadata = { "offset" : _get_declination_of_b_plane_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def declination_of_b_plane(self) -> float:
        """Declination of the B-Plane Normal."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_declination_of_b_plane_metadata)

    _set_declination_of_b_plane_metadata = { "offset" : _set_declination_of_b_plane_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @declination_of_b_plane.setter
    def declination_of_b_plane(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_declination_of_b_plane_metadata, value)

    _get_b_dot_r_first_b_vector_metadata = { "offset" : _get_b_dot_r_first_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_dot_r_first_b_vector(self) -> float:
        """B vector dotted with R vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_dot_r_first_b_vector_metadata)

    _set_b_dot_r_first_b_vector_metadata = { "offset" : _set_b_dot_r_first_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_dot_r_first_b_vector.setter
    def b_dot_r_first_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_dot_r_first_b_vector_metadata, value)

    _get_b_dot_t_second_b_vector_metadata = { "offset" : _get_b_dot_t_second_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_dot_t_second_b_vector(self) -> float:
        """B vector dotted with T vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_dot_t_second_b_vector_metadata)

    _set_b_dot_t_second_b_vector_metadata = { "offset" : _set_b_dot_t_second_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_dot_t_second_b_vector.setter
    def b_dot_t_second_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_dot_t_second_b_vector_metadata, value)

    _get_hyperbolic_turning_angle_metadata = { "offset" : _get_hyperbolic_turning_angle_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def hyperbolic_turning_angle(self) -> float:
        """Hyperbolic turning angle."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_hyperbolic_turning_angle_metadata)

    _set_hyperbolic_turning_angle_metadata = { "offset" : _set_hyperbolic_turning_angle_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @hyperbolic_turning_angle.setter
    def hyperbolic_turning_angle(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_hyperbolic_turning_angle_metadata, value)

    _get_orbital_c3_energy_metadata = { "offset" : _get_orbital_c3_energy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def orbital_c3_energy(self) -> float:
        """Orbital C3 Energy."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_orbital_c3_energy_metadata)

    _set_orbital_c3_energy_metadata = { "offset" : _set_orbital_c3_energy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @orbital_c3_energy.setter
    def orbital_c3_energy(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_orbital_c3_energy_metadata, value)

    _get_hyperbolic_v_infinity_metadata = { "offset" : _get_hyperbolic_v_infinity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def hyperbolic_v_infinity(self) -> float:
        """Hyperbolic V infinity."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_hyperbolic_v_infinity_metadata)

    _set_hyperbolic_v_infinity_metadata = { "offset" : _set_hyperbolic_v_infinity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @hyperbolic_v_infinity.setter
    def hyperbolic_v_infinity(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_hyperbolic_v_infinity_metadata, value)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """Semi-major axis."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_semimajor_axis_metadata, value)

    _get_b_dot_t_first_b_vector_metadata = { "offset" : _get_b_dot_t_first_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_dot_t_first_b_vector(self) -> float:
        """B vector dotted with T vector used as the first quantity to define the B vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_dot_t_first_b_vector_metadata)

    _set_b_dot_t_first_b_vector_metadata = { "offset" : _set_b_dot_t_first_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_dot_t_first_b_vector.setter
    def b_dot_t_first_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_dot_t_first_b_vector_metadata, value)

    _get_b_theta_first_b_vector_metadata = { "offset" : _get_b_theta_first_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_theta_first_b_vector(self) -> float:
        """Angle between the B vector and T vector used as the first quantity to define the B vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_theta_first_b_vector_metadata)

    _set_b_theta_first_b_vector_metadata = { "offset" : _set_b_theta_first_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_theta_first_b_vector.setter
    def b_theta_first_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_theta_first_b_vector_metadata, value)

    _get_b_dot_r_second_b_vector_metadata = { "offset" : _get_b_dot_r_second_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_dot_r_second_b_vector(self) -> float:
        """B vector dotted with T vector used as the second quantity to define the B vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_dot_r_second_b_vector_metadata)

    _set_b_dot_r_second_b_vector_metadata = { "offset" : _set_b_dot_r_second_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_dot_r_second_b_vector.setter
    def b_dot_r_second_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_dot_r_second_b_vector_metadata, value)

    _get_b_magnitude_second_b_vector_metadata = { "offset" : _get_b_magnitude_second_b_vector_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b_magnitude_second_b_vector(self) -> float:
        """Magnitude of the B vector used as the second quantity to define the B vector."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_b_magnitude_second_b_vector_metadata)

    _set_b_magnitude_second_b_vector_metadata = { "offset" : _set_b_magnitude_second_b_vector_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b_magnitude_second_b_vector.setter
    def b_magnitude_second_b_vector(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_b_magnitude_second_b_vector_metadata, value)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def true_anomaly(self) -> float:
        """True Anomaly."""
        return self._intf.get_property(ElementBPlane._metadata, ElementBPlane._get_true_anomaly_metadata)

    _set_true_anomaly_metadata = { "offset" : _set_true_anomaly_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @true_anomaly.setter
    def true_anomaly(self, value:float) -> None:
        return self._intf.set_property(ElementBPlane._metadata, ElementBPlane._set_true_anomaly_metadata, value)

    _property_names[right_ascension_of_b_plane] = "right_ascension_of_b_plane"
    _property_names[declination_of_b_plane] = "declination_of_b_plane"
    _property_names[b_dot_r_first_b_vector] = "b_dot_r_first_b_vector"
    _property_names[b_dot_t_second_b_vector] = "b_dot_t_second_b_vector"
    _property_names[hyperbolic_turning_angle] = "hyperbolic_turning_angle"
    _property_names[orbital_c3_energy] = "orbital_c3_energy"
    _property_names[hyperbolic_v_infinity] = "hyperbolic_v_infinity"
    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[b_dot_t_first_b_vector] = "b_dot_t_first_b_vector"
    _property_names[b_theta_first_b_vector] = "b_theta_first_b_vector"
    _property_names[b_dot_r_second_b_vector] = "b_dot_r_second_b_vector"
    _property_names[b_magnitude_second_b_vector] = "b_magnitude_second_b_vector"
    _property_names[true_anomaly] = "true_anomaly"

    def __init__(self, source_object=None):
        """Construct an object of type ElementBPlane."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementBPlane)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementBPlane, [ElementBPlane, IElement])

agcls.AgClassCatalog.add_catalog_entry((5159631324272900961, 8893182645510748334), ElementBPlane)
agcls.AgTypeNameMap["ElementBPlane"] = ElementBPlane

class ElementSphericalRangeRate(IElement, SupportsDeleteCallback):
    """Properties for Spherical Range Rate elements."""

    _num_methods = 12
    _vtable_offset = IElement._vtable_offset + IElement._num_methods
    _get_right_ascension_method_offset = 1
    _set_right_ascension_method_offset = 2
    _get_declination_method_offset = 3
    _set_declination_method_offset = 4
    _get_range_method_offset = 5
    _set_range_method_offset = 6
    _get_right_ascension_rate_method_offset = 7
    _set_right_ascension_rate_method_offset = 8
    _get_declination_rate_method_offset = 9
    _set_declination_rate_method_offset = 10
    _get_range_rate_method_offset = 11
    _set_range_rate_method_offset = 12
    _metadata = {
        "iid_data" : (5305548903845118989, 13104622450174055820),
        "vtable_reference" : IElement._vtable_offset + IElement._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ElementSphericalRangeRate)

    _get_right_ascension_metadata = { "offset" : _get_right_ascension_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def right_ascension(self) -> typing.Any:
        """Defined as the angle from the X axis to the projection of the satellite position vector in the equatorial plane measured as positive in the direction of the Y axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_right_ascension_metadata)

    _set_right_ascension_metadata = { "offset" : _set_right_ascension_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @right_ascension.setter
    def right_ascension(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_right_ascension_metadata, value)

    _get_declination_metadata = { "offset" : _get_declination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def declination(self) -> typing.Any:
        """Defined as the angle between the satellite position vector and the inertial equatorial plane measured as positive toward the positive inertial Z axis. Uses Angle Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_declination_metadata)

    _set_declination_metadata = { "offset" : _set_declination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @declination.setter
    def declination(self, value:typing.Any) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_declination_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """The magnitude of the satellite position vector. Uses Distance Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_range_metadata)

    _set_range_metadata = { "offset" : _set_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @range.setter
    def range(self, value:float) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_range_metadata, value)

    _get_right_ascension_rate_metadata = { "offset" : _get_right_ascension_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def right_ascension_rate(self) -> float:
        """The rate of change of the right ascension. Uses Angle Rate Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_right_ascension_rate_metadata)

    _set_right_ascension_rate_metadata = { "offset" : _set_right_ascension_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @right_ascension_rate.setter
    def right_ascension_rate(self, value:float) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_right_ascension_rate_metadata, value)

    _get_declination_rate_metadata = { "offset" : _get_declination_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def declination_rate(self) -> float:
        """The rate of change of the declination. Uses Angle Rate Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_declination_rate_metadata)

    _set_declination_rate_metadata = { "offset" : _set_declination_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @declination_rate.setter
    def declination_rate(self, value:float) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_declination_rate_metadata, value)

    _get_range_rate_metadata = { "offset" : _get_range_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range_rate(self) -> float:
        """The rate of change of the range. Uses Rate Dimension."""
        return self._intf.get_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._get_range_rate_metadata)

    _set_range_rate_metadata = { "offset" : _set_range_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @range_rate.setter
    def range_rate(self, value:float) -> None:
        return self._intf.set_property(ElementSphericalRangeRate._metadata, ElementSphericalRangeRate._set_range_rate_metadata, value)

    _property_names[right_ascension] = "right_ascension"
    _property_names[declination] = "declination"
    _property_names[range] = "range"
    _property_names[right_ascension_rate] = "right_ascension_rate"
    _property_names[declination_rate] = "declination_rate"
    _property_names[range_rate] = "range_rate"

    def __init__(self, source_object=None):
        """Construct an object of type ElementSphericalRangeRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ElementSphericalRangeRate)
        IElement.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IElement._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ElementSphericalRangeRate, [ElementSphericalRangeRate, IElement])

agcls.AgClassCatalog.add_catalog_entry((4959039473664888368, 13118382122406988682), ElementSphericalRangeRate)
agcls.AgTypeNameMap["ElementSphericalRangeRate"] = ElementSphericalRangeRate

class MCSPropagate(IMCSSegment, IComponentInfo, ICloneable, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Propagate segment."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propagator_name_method_offset = 1
    _set_propagator_name_method_offset = 2
    _get_stopping_conditions_method_offset = 3
    _get_min_propagation_time_method_offset = 4
    _set_min_propagation_time_method_offset = 5
    _get_max_propagation_time_method_offset = 6
    _set_max_propagation_time_method_offset = 7
    _get_enable_max_propagation_time_method_offset = 8
    _set_enable_max_propagation_time_method_offset = 9
    _get_enable_warning_message_method_offset = 10
    _set_enable_warning_message_method_offset = 11
    _enable_control_parameter_method_offset = 12
    _disable_control_parameter_method_offset = 13
    _is_control_parameter_enabled_method_offset = 14
    _get_control_parameters_available_method_offset = 15
    _get_override_max_propagation_time_method_offset = 16
    _set_override_max_propagation_time_method_offset = 17
    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 18
    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 19
    _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 20
    _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 21
    _metadata = {
        "iid_data" : (4982104245615881734, 11405336420499347081),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSPropagate)

    _get_propagator_name_metadata = { "offset" : _get_propagator_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propagator_name(self) -> str:
        """Get or set the propagator."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_propagator_name_metadata)

    _set_propagator_name_metadata = { "offset" : _set_propagator_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @propagator_name.setter
    def propagator_name(self, value:str) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_propagator_name_metadata, value)

    _get_stopping_conditions_metadata = { "offset" : _get_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def stopping_conditions(self) -> "StoppingConditionCollection":
        """Get the list of stopping conditions defined for the segment."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_stopping_conditions_metadata)

    _get_min_propagation_time_metadata = { "offset" : _get_min_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_propagation_time(self) -> float:
        """Get or set the minimum time that must elapse from the beginning of the segment until Astrogator will begin checking stopping conditions for satisfaction. Uses Time Dimension."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_min_propagation_time_metadata)

    _set_min_propagation_time_metadata = { "offset" : _set_min_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_propagation_time.setter
    def min_propagation_time(self, value:float) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_min_propagation_time_metadata, value)

    _get_max_propagation_time_metadata = { "offset" : _get_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_propagation_time(self) -> float:
        """Get or set the maximum propagation time, after which the segment will end regardless of whether the stopping conditions have been satisfied. Uses Time Dimension."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_max_propagation_time_metadata)

    _set_max_propagation_time_metadata = { "offset" : _set_max_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_propagation_time.setter
    def max_propagation_time(self, value:float) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_max_propagation_time_metadata, value)

    _get_enable_max_propagation_time_metadata = { "offset" : _get_enable_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_max_propagation_time(self) -> bool:
        """If true, the maximum propagation time is enforced."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_enable_max_propagation_time_metadata)

    _set_enable_max_propagation_time_metadata = { "offset" : _set_enable_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_max_propagation_time.setter
    def enable_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_enable_max_propagation_time_metadata, value)

    _get_enable_warning_message_metadata = { "offset" : _get_enable_warning_message_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_warning_message(self) -> bool:
        """If true, Astrogator will issue a warning message if propagation is stopped by the Maximum Propagation Time parameter."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_enable_warning_message_metadata)

    _set_enable_warning_message_metadata = { "offset" : _set_enable_warning_message_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_warning_message.setter
    def enable_warning_message(self, value:bool) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_enable_warning_message_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced),) }
    def enable_control_parameter(self, param:"ControlAdvanced") -> None:
        """Enable or disables the specified control parameter."""
        return self._intf.invoke(MCSPropagate._metadata, MCSPropagate._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced),) }
    def disable_control_parameter(self, param:"ControlAdvanced") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSPropagate._metadata, MCSPropagate._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlAdvanced") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSPropagate._metadata, MCSPropagate._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_control_parameters_available_metadata)

    _get_override_max_propagation_time_metadata = { "offset" : _get_override_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def override_max_propagation_time(self) -> bool:
        """Override Maximum Propagation Time - if there is a duration or epoch stopping condition that occurs after the maximum propagation time, ignore the maximum propagation time."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_override_max_propagation_time_metadata)

    _set_override_max_propagation_time_metadata = { "offset" : _set_override_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @override_max_propagation_time.setter
    def override_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_override_max_propagation_time_metadata, value)

    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self) -> bool:
        """Stop immediately if propagation begins beyond an active epoch stopping condition."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata)

    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_stop_for_initially_surpassed_epoch_stopping_conditions.setter
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self, value:bool) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata, value)

    _get_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_reinitialize_stm_at_start_of_segment_propagation(self) -> bool:
        """If this segment is propagating the state transition matrix, reset it to the identity matrix at the start of the segment."""
        return self._intf.get_property(MCSPropagate._metadata, MCSPropagate._get_should_reinitialize_stm_at_start_of_segment_propagation_metadata)

    _set_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_reinitialize_stm_at_start_of_segment_propagation.setter
    def should_reinitialize_stm_at_start_of_segment_propagation(self, value:bool) -> None:
        return self._intf.set_property(MCSPropagate._metadata, MCSPropagate._set_should_reinitialize_stm_at_start_of_segment_propagation_metadata, value)

    _property_names[propagator_name] = "propagator_name"
    _property_names[stopping_conditions] = "stopping_conditions"
    _property_names[min_propagation_time] = "min_propagation_time"
    _property_names[max_propagation_time] = "max_propagation_time"
    _property_names[enable_max_propagation_time] = "enable_max_propagation_time"
    _property_names[enable_warning_message] = "enable_warning_message"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[override_max_propagation_time] = "override_max_propagation_time"
    _property_names[should_stop_for_initially_surpassed_epoch_stopping_conditions] = "should_stop_for_initially_surpassed_epoch_stopping_conditions"
    _property_names[should_reinitialize_stm_at_start_of_segment_propagation] = "should_reinitialize_stm_at_start_of_segment_propagation"

    def __init__(self, source_object=None):
        """Construct an object of type MCSPropagate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSPropagate)
        IMCSSegment.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSPropagate, [MCSPropagate, IMCSSegment, IComponentInfo, ICloneable, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5194969086151067853, 10177006802175344288), MCSPropagate)
agcls.AgTypeNameMap["MCSPropagate"] = MCSPropagate

class State(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Spacecraft Parameters properties for the spacecraft configuration."""

    _num_methods = 33
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_element_type_method_offset = 1
    _set_element_type_method_offset = 2
    _get_element_method_offset = 3
    _get_epoch_method_offset = 4
    _set_epoch_method_offset = 5
    _get_coord_system_name_method_offset = 6
    _get_dry_mass_method_offset = 7
    _set_dry_mass_method_offset = 8
    _get_fuel_mass_method_offset = 9
    _set_fuel_mass_method_offset = 10
    _get_drag_area_method_offset = 11
    _set_drag_area_method_offset = 12
    _get_srp_area_method_offset = 13
    _set_srp_area_method_offset = 14
    _get_tank_pressure_method_offset = 15
    _set_tank_pressure_method_offset = 16
    _get_tank_temperature_method_offset = 17
    _set_tank_temperature_method_offset = 18
    _get_fuel_density_method_offset = 19
    _set_fuel_density_method_offset = 20
    _get_cr_method_offset = 21
    _set_cr_method_offset = 22
    _get_cd_method_offset = 23
    _set_cd_method_offset = 24
    _get_radiation_pressure_coefficient_method_offset = 25
    _set_radiation_pressure_coefficient_method_offset = 26
    _get_radiation_pressure_area_method_offset = 27
    _set_radiation_pressure_area_method_offset = 28
    _get_k1_method_offset = 29
    _set_k1_method_offset = 30
    _get_k2_method_offset = 31
    _set_k2_method_offset = 32
    _get_in_frame_name_method_offset = 33
    _metadata = {
        "iid_data" : (4804985124432915391, 9179349462890422656),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, State)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementSetType),) }
    @property
    def element_type(self) -> "ElementSetType":
        """Get the element type."""
        return self._intf.get_property(State._metadata, State._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementSetType),) }
    def set_element_type(self, element_type:"ElementSetType") -> None:
        """Set the element type."""
        return self._intf.invoke(State._metadata, State._set_element_type_metadata, element_type)

    _get_element_metadata = { "offset" : _get_element_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def element(self) -> "IElement":
        """Return the currently selected element type."""
        return self._intf.get_property(State._metadata, State._get_element_metadata)

    _get_epoch_metadata = { "offset" : _get_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def epoch(self) -> typing.Any:
        """Get or set the epoch of the Orbit State. Uses DateFormat Dimension."""
        return self._intf.get_property(State._metadata, State._get_epoch_metadata)

    _set_epoch_metadata = { "offset" : _set_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @epoch.setter
    def epoch(self, epoch:typing.Any) -> None:
        return self._intf.set_property(State._metadata, State._set_epoch_metadata, epoch)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get the coordinate system."""
        return self._intf.get_property(State._metadata, State._get_coord_system_name_metadata)

    _get_dry_mass_metadata = { "offset" : _get_dry_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def dry_mass(self) -> float:
        """Get or set the mass of the spacecraft exclusive of propellant. Uses Mass Dimension."""
        return self._intf.get_property(State._metadata, State._get_dry_mass_metadata)

    _set_dry_mass_metadata = { "offset" : _set_dry_mass_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @dry_mass.setter
    def dry_mass(self, dry_mass:float) -> None:
        return self._intf.set_property(State._metadata, State._set_dry_mass_metadata, dry_mass)

    _get_fuel_mass_metadata = { "offset" : _get_fuel_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_mass(self) -> float:
        """Get or set the mass of the spacecraft propellant. Uses Mass Dimension."""
        return self._intf.get_property(State._metadata, State._get_fuel_mass_metadata)

    _set_fuel_mass_metadata = { "offset" : _set_fuel_mass_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_mass.setter
    def fuel_mass(self, fuel_mass:float) -> None:
        return self._intf.set_property(State._metadata, State._set_fuel_mass_metadata, fuel_mass)

    _get_drag_area_metadata = { "offset" : _get_drag_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def drag_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of motion, used for atmospheric drag calculations. Uses SmallArea Dimension."""
        return self._intf.get_property(State._metadata, State._get_drag_area_metadata)

    _set_drag_area_metadata = { "offset" : _set_drag_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @drag_area.setter
    def drag_area(self, fuel_mass:float) -> None:
        return self._intf.set_property(State._metadata, State._set_drag_area_metadata, fuel_mass)

    _get_srp_area_metadata = { "offset" : _get_srp_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def srp_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of solar radiation, used for solar radiation calculations. Uses SmallArea Dimension."""
        return self._intf.get_property(State._metadata, State._get_srp_area_metadata)

    _set_srp_area_metadata = { "offset" : _set_srp_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @srp_area.setter
    def srp_area(self, srp_area:float) -> None:
        return self._intf.set_property(State._metadata, State._set_srp_area_metadata, srp_area)

    _get_tank_pressure_metadata = { "offset" : _get_tank_pressure_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tank_pressure(self) -> float:
        """Get or set the fuel tank pressure. Uses Pressure Dimension."""
        return self._intf.get_property(State._metadata, State._get_tank_pressure_metadata)

    _set_tank_pressure_metadata = { "offset" : _set_tank_pressure_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tank_pressure.setter
    def tank_pressure(self, tank_pressure:float) -> None:
        return self._intf.set_property(State._metadata, State._set_tank_pressure_metadata, tank_pressure)

    _get_tank_temperature_metadata = { "offset" : _get_tank_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tank_temperature(self) -> float:
        """Get or set the temperature of the fuel tank. Uses Temperature Dimension."""
        return self._intf.get_property(State._metadata, State._get_tank_temperature_metadata)

    _set_tank_temperature_metadata = { "offset" : _set_tank_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tank_temperature.setter
    def tank_temperature(self, tank_temperature:float) -> None:
        return self._intf.set_property(State._metadata, State._set_tank_temperature_metadata, tank_temperature)

    _get_fuel_density_metadata = { "offset" : _get_fuel_density_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_density(self) -> float:
        """Get or set the density of the fuel tank. Uses SmallDensity Dimension."""
        return self._intf.get_property(State._metadata, State._get_fuel_density_metadata)

    _set_fuel_density_metadata = { "offset" : _set_fuel_density_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_density.setter
    def fuel_density(self, fuel_density:float) -> None:
        return self._intf.set_property(State._metadata, State._set_fuel_density_metadata, fuel_density)

    _get_cr_metadata = { "offset" : _get_cr_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cr(self) -> float:
        """Get or set the reflectivity of the spacecraft used for solar radiation pressure calculations, where 2.0 is fully reflective and 1.0 is not reflective at all. Dimensionless."""
        return self._intf.get_property(State._metadata, State._get_cr_metadata)

    _set_cr_metadata = { "offset" : _set_cr_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cr.setter
    def cr(self, cr:float) -> None:
        return self._intf.set_property(State._metadata, State._set_cr_metadata, cr)

    _get_cd_metadata = { "offset" : _get_cd_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd(self) -> float:
        """Get or set the dimensionless drag coefficient associated with the drag area. Dimensionless."""
        return self._intf.get_property(State._metadata, State._get_cd_metadata)

    _set_cd_metadata = { "offset" : _set_cd_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd.setter
    def cd(self, cd:float) -> None:
        return self._intf.set_property(State._metadata, State._set_cd_metadata, cd)

    _get_radiation_pressure_coefficient_metadata = { "offset" : _get_radiation_pressure_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radiation_pressure_coefficient(self) -> float:
        """Get or set the reflectivity of the spacecraft used for central body radiation pressure (albedo / thermal pressure) calculations, where 2.0 is fully reflective and 1.0 is not reflective at all. Dimensionless."""
        return self._intf.get_property(State._metadata, State._get_radiation_pressure_coefficient_metadata)

    _set_radiation_pressure_coefficient_metadata = { "offset" : _set_radiation_pressure_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radiation_pressure_coefficient.setter
    def radiation_pressure_coefficient(self, radiation_pressure_coeff:float) -> None:
        return self._intf.set_property(State._metadata, State._set_radiation_pressure_coefficient_metadata, radiation_pressure_coeff)

    _get_radiation_pressure_area_metadata = { "offset" : _get_radiation_pressure_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radiation_pressure_area(self) -> float:
        """Get or set the cross-sectional area of the spacecraft assumed perpendicular to the direction of central body radiation, used for central body radiation (albedo / thermal pressure) calculations. Uses Small Area Dimension."""
        return self._intf.get_property(State._metadata, State._get_radiation_pressure_area_metadata)

    _set_radiation_pressure_area_metadata = { "offset" : _set_radiation_pressure_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radiation_pressure_area.setter
    def radiation_pressure_area(self, rad_pressure_area:float) -> None:
        return self._intf.set_property(State._metadata, State._set_radiation_pressure_area_metadata, rad_pressure_area)

    _get_k1_metadata = { "offset" : _get_k1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k1(self) -> float:
        """If you are using a non-spherical SRP model, this field defines the model's GPS solar radiation pressure K1 (scale) value. Dimensionless."""
        return self._intf.get_property(State._metadata, State._get_k1_metadata)

    _set_k1_metadata = { "offset" : _set_k1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k1.setter
    def k1(self, k1:float) -> None:
        return self._intf.set_property(State._metadata, State._set_k1_metadata, k1)

    _get_k2_metadata = { "offset" : _get_k2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k2(self) -> float:
        """If you are using a non-spherical SRP model, this field defines the model's GPS solar radiation pressure K2 (scale) value. Dimensionless."""
        return self._intf.get_property(State._metadata, State._get_k2_metadata)

    _set_k2_metadata = { "offset" : _set_k2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k2.setter
    def k2(self, k2:float) -> None:
        return self._intf.set_property(State._metadata, State._set_k2_metadata, k2)

    _get_in_frame_name_metadata = { "offset" : _get_in_frame_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_in_frame_name(self, frame_name:str) -> "State":
        """Get the orbit state in the specified frame."""
        return self._intf.invoke(State._metadata, State._get_in_frame_name_metadata, frame_name, OutArg())

    _property_names[element_type] = "element_type"
    _property_names[element] = "element"
    _property_names[epoch] = "epoch"
    _property_names[coord_system_name] = "coord_system_name"
    _property_names[dry_mass] = "dry_mass"
    _property_names[fuel_mass] = "fuel_mass"
    _property_names[drag_area] = "drag_area"
    _property_names[srp_area] = "srp_area"
    _property_names[tank_pressure] = "tank_pressure"
    _property_names[tank_temperature] = "tank_temperature"
    _property_names[fuel_density] = "fuel_density"
    _property_names[cr] = "cr"
    _property_names[cd] = "cd"
    _property_names[radiation_pressure_coefficient] = "radiation_pressure_coefficient"
    _property_names[radiation_pressure_area] = "radiation_pressure_area"
    _property_names[k1] = "k1"
    _property_names[k2] = "k2"

    def __init__(self, source_object=None):
        """Construct an object of type State."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, State)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, State, [State, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4795127631371666389, 13941908390852527797), State)
agcls.AgTypeNameMap["State"] = State

class StoppingConditionCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The list of Stopping Conditions."""

    _num_methods = 10
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _cut_method_offset = 6
    _paste_method_offset = 7
    _insert_copy_method_offset = 8
    _get_item_by_index_method_offset = 9
    _get_item_by_name_method_offset = 10
    _metadata = {
        "iid_data" : (5630863724408399388, 12206717745624651652),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StoppingConditionCollection)
    def __iter__(self):
        """Create an iterator for the StoppingConditionCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "StoppingConditionElement":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "StoppingConditionElement":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, condition_name:str) -> "StoppingConditionElement":
        """Add a stopping condition."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._add_metadata, condition_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a stopping condition."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(StoppingConditionCollection._metadata, StoppingConditionCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(StoppingConditionCollection._metadata, StoppingConditionCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the stopping condition into the clipboard and removes the stopping condition from the list."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "StoppingConditionElement":
        """Pastes the stopping condition from the clipboard and inserts into the list."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("StoppingConditionElement"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, stop_cond:"StoppingConditionElement") -> "StoppingConditionElement":
        """Copy the stopping condition and inserts the copy into the list."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._insert_copy_metadata, stop_cond, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "StoppingConditionElement":
        """Retrieve a stopping condition in the collection by index."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "StoppingConditionElement":
        """Retrieve a stopping condition in the collection by name."""
        return self._intf.invoke(StoppingConditionCollection._metadata, StoppingConditionCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type StoppingConditionCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StoppingConditionCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StoppingConditionCollection, [StoppingConditionCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5312353168653404039, 12679003996478946741), StoppingConditionCollection)
agcls.AgTypeNameMap["StoppingConditionCollection"] = StoppingConditionCollection

class AccessStoppingCondition(IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for an access stopping condition."""

    _num_methods = 28
    _vtable_offset = IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods
    _get_time_convergence_method_offset = 1
    _set_time_convergence_method_offset = 2
    _get_repeat_count_method_offset = 3
    _set_repeat_count_method_offset = 4
    _get_inherited_method_offset = 5
    _set_inherited_method_offset = 6
    _get_max_trip_times_method_offset = 7
    _set_max_trip_times_method_offset = 8
    _get_sequence_method_offset = 9
    _set_sequence_method_offset = 10
    _get_constraints_method_offset = 11
    _get_criterion_method_offset = 12
    _set_criterion_method_offset = 13
    _get_before_conditions_method_offset = 14
    _get_aberration_type_method_offset = 15
    _set_aberration_type_method_offset = 16
    _set_base_selection_method_offset = 17
    _get_base_selection_type_method_offset = 18
    _get_base_selection_method_offset = 19
    _get_clock_host_method_offset = 20
    _set_clock_host_method_offset = 21
    _get_signal_sense_method_offset = 22
    _set_signal_sense_method_offset = 23
    _get_target_object_method_offset = 24
    _get_time_delay_convergence_tolerance_method_offset = 25
    _set_time_delay_convergence_tolerance_method_offset = 26
    _get_use_light_time_delay_method_offset = 27
    _set_use_light_time_delay_method_offset = 28
    _metadata = {
        "iid_data" : (4897277133588344594, 316659950229172406),
        "vtable_reference" : IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AccessStoppingCondition)

    _get_time_convergence_metadata = { "offset" : _get_time_convergence_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_convergence(self) -> float:
        """Get or set the time tolerance that is used by the access algorithms to determine the start times and stop times of access intervals. Uses Time dimension."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_time_convergence_metadata)

    _set_time_convergence_metadata = { "offset" : _set_time_convergence_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_convergence.setter
    def time_convergence(self, value:float) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_time_convergence_metadata, value)

    _get_repeat_count_metadata = { "offset" : _get_repeat_count_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def repeat_count(self) -> float:
        """Get or set the number of times the condition must be satisfied before the propagation ends or moves on to the designated automatic sequence. Dimensionless."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_repeat_count_metadata)

    _set_repeat_count_metadata = { "offset" : _set_repeat_count_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @repeat_count.setter
    def repeat_count(self, value:float) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_repeat_count_metadata, value)

    _get_inherited_metadata = { "offset" : _get_inherited_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def inherited(self) -> bool:
        """Condition Inherited by Automatic Sequences - if true, the stopping condition will be applied to any automatic sequences activated within the same segment."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_inherited_metadata)

    _set_inherited_metadata = { "offset" : _set_inherited_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @inherited.setter
    def inherited(self, value:bool) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_inherited_metadata, value)

    _get_max_trip_times_metadata = { "offset" : _get_max_trip_times_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_trip_times(self) -> float:
        """Get or set the maximum number of times that the stopping condition will be applied - and any resulting automatic sequences executed. Dimensionless."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_max_trip_times_metadata)

    _set_max_trip_times_metadata = { "offset" : _set_max_trip_times_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_trip_times.setter
    def max_trip_times(self, value:float) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_max_trip_times_metadata, value)

    _get_sequence_metadata = { "offset" : _get_sequence_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def sequence(self) -> str:
        """Get or set the automatic sequence to trigger if the highlighted stopping condition is satisfied."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_sequence_metadata)

    _set_sequence_metadata = { "offset" : _set_sequence_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @sequence.setter
    def sequence(self, value:str) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_sequence_metadata, value)

    _get_constraints_metadata = { "offset" : _get_constraints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def constraints(self) -> "ConstraintCollection":
        """Further conditions that must be met in order for the stopping condition to be deemed satisfied."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_constraints_metadata)

    _get_criterion_metadata = { "offset" : _get_criterion_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccessCriterion),) }
    @property
    def criterion(self) -> "AccessCriterion":
        """Specify the direction from which the stopping condition value must be achieved."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_criterion_metadata)

    _set_criterion_metadata = { "offset" : _set_criterion_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccessCriterion),) }
    @criterion.setter
    def criterion(self, value:"AccessCriterion") -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_criterion_metadata, value)

    _get_before_conditions_metadata = { "offset" : _get_before_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def before_conditions(self) -> "StoppingConditionCollection":
        """A 'before' stopping condition is used to define a stopping condition that depends on two events. Astrogator will ignore a stopping condition until its 'before' conditions are met. Astrogator then interpolates backwards to the normal stopping condition."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_before_conditions_metadata)

    _get_aberration_type_metadata = { "offset" : _get_aberration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AberrationType),) }
    @property
    def aberration_type(self) -> "AberrationType":
        """Get or set the model of aberration to be used in access computations."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_aberration_type_metadata)

    _set_aberration_type_metadata = { "offset" : _set_aberration_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AberrationType),) }
    @aberration_type.setter
    def aberration_type(self, value:"AberrationType") -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_aberration_type_metadata, value)

    _set_base_selection_metadata = { "offset" : _set_base_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BaseSelection),) }
    def set_base_selection(self, selection:"BaseSelection") -> None:
        """BaseSelection."""
        return self._intf.invoke(AccessStoppingCondition._metadata, AccessStoppingCondition._set_base_selection_metadata, selection)

    _get_base_selection_type_metadata = { "offset" : _get_base_selection_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BaseSelection),) }
    @property
    def base_selection_type(self) -> "BaseSelection":
        """Get the base object for the access calculation."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_base_selection_type_metadata)

    _get_base_selection_metadata = { "offset" : _get_base_selection_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def base_selection(self) -> "ILinkToObject":
        """Return the base selection object."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_base_selection_metadata)

    _get_clock_host_metadata = { "offset" : _get_clock_host_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IvClockHost),) }
    @property
    def clock_host(self) -> "IvClockHost":
        """Time values are reported with a clock colocated with the clock host object."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_clock_host_metadata)

    _set_clock_host_metadata = { "offset" : _set_clock_host_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IvClockHost),) }
    @clock_host.setter
    def clock_host(self, value:"IvClockHost") -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_clock_host_metadata, value)

    _get_signal_sense_metadata = { "offset" : _get_signal_sense_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IvTimeSense),) }
    @property
    def signal_sense(self) -> "IvTimeSense":
        """Get or set the direction of the signal."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_signal_sense_metadata)

    _set_signal_sense_metadata = { "offset" : _set_signal_sense_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IvTimeSense),) }
    @signal_sense.setter
    def signal_sense(self, value:"IvTimeSense") -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_signal_sense_metadata, value)

    _get_target_object_metadata = { "offset" : _get_target_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def target_object(self) -> "ILinkToObject":
        """Get the target object for the access calculation."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_target_object_metadata)

    _get_time_delay_convergence_tolerance_metadata = { "offset" : _get_time_delay_convergence_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_delay_convergence_tolerance(self) -> float:
        """Get or set the tolerance used when iterating to determine the light time delay. The iteration stops when the improvement in the value is less than this tolerance. Uses Time Dimension."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_time_delay_convergence_tolerance_metadata)

    _set_time_delay_convergence_tolerance_metadata = { "offset" : _set_time_delay_convergence_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_delay_convergence_tolerance.setter
    def time_delay_convergence_tolerance(self, value:float) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_time_delay_convergence_tolerance_metadata, value)

    _get_use_light_time_delay_metadata = { "offset" : _get_use_light_time_delay_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_light_time_delay(self) -> bool:
        """Whether to consider light time delay in access computations."""
        return self._intf.get_property(AccessStoppingCondition._metadata, AccessStoppingCondition._get_use_light_time_delay_metadata)

    _set_use_light_time_delay_metadata = { "offset" : _set_use_light_time_delay_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_light_time_delay.setter
    def use_light_time_delay(self, value:bool) -> None:
        return self._intf.set_property(AccessStoppingCondition._metadata, AccessStoppingCondition._set_use_light_time_delay_metadata, value)

    _property_names[time_convergence] = "time_convergence"
    _property_names[repeat_count] = "repeat_count"
    _property_names[inherited] = "inherited"
    _property_names[max_trip_times] = "max_trip_times"
    _property_names[sequence] = "sequence"
    _property_names[constraints] = "constraints"
    _property_names[criterion] = "criterion"
    _property_names[before_conditions] = "before_conditions"
    _property_names[aberration_type] = "aberration_type"
    _property_names[base_selection_type] = "base_selection_type"
    _property_names[base_selection] = "base_selection"
    _property_names[clock_host] = "clock_host"
    _property_names[signal_sense] = "signal_sense"
    _property_names[target_object] = "target_object"
    _property_names[time_delay_convergence_tolerance] = "time_delay_convergence_tolerance"
    _property_names[use_light_time_delay] = "use_light_time_delay"

    def __init__(self, source_object=None):
        """Construct an object of type AccessStoppingCondition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AccessStoppingCondition)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
        IStoppingConditionComponent.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
        IStoppingConditionComponent._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AccessStoppingCondition, [AccessStoppingCondition, IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4811929967101649166, 10033959377873712801), AccessStoppingCondition)
agcls.AgTypeNameMap["AccessStoppingCondition"] = AccessStoppingCondition

class LightingStoppingCondition(IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a lighting stopping condition."""

    _num_methods = 18
    _vtable_offset = IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods
    _get_max_trip_times_method_offset = 1
    _set_max_trip_times_method_offset = 2
    _get_repeat_count_method_offset = 3
    _set_repeat_count_method_offset = 4
    _get_constraints_method_offset = 5
    _get_before_conditions_method_offset = 6
    _get_inherited_method_offset = 7
    _set_inherited_method_offset = 8
    _get_sequence_method_offset = 9
    _set_sequence_method_offset = 10
    _get_condition_method_offset = 11
    _set_condition_method_offset = 12
    _get_eclipsing_bodies_list_source_method_offset = 13
    _set_eclipsing_bodies_list_source_method_offset = 14
    _add_eclipsing_body_method_offset = 15
    _remove_eclipsing_body_method_offset = 16
    _get_eclipsing_bodies_method_offset = 17
    _get_available_eclipsing_bodies_method_offset = 18
    _metadata = {
        "iid_data" : (5629329659757080199, 7326471514331213698),
        "vtable_reference" : IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, LightingStoppingCondition)

    _get_max_trip_times_metadata = { "offset" : _get_max_trip_times_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_trip_times(self) -> float:
        """Rhe maximum number of times that the stopping condition will be applied - and any resulting automatic sequences executed. Dimensionless."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_max_trip_times_metadata)

    _set_max_trip_times_metadata = { "offset" : _set_max_trip_times_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_trip_times.setter
    def max_trip_times(self, value:float) -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_max_trip_times_metadata, value)

    _get_repeat_count_metadata = { "offset" : _get_repeat_count_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def repeat_count(self) -> float:
        """Get or set the number of times the condition must be satisfied before the propagation ends or moves on to the designated automatic sequence. Dimensionless."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_repeat_count_metadata)

    _set_repeat_count_metadata = { "offset" : _set_repeat_count_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @repeat_count.setter
    def repeat_count(self, value:float) -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_repeat_count_metadata, value)

    _get_constraints_metadata = { "offset" : _get_constraints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def constraints(self) -> "ConstraintCollection":
        """Further conditions that must be met in order for the stopping condition to be deemed satisfied."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_constraints_metadata)

    _get_before_conditions_metadata = { "offset" : _get_before_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def before_conditions(self) -> "StoppingConditionCollection":
        """A 'before' stopping condition is used to define a stopping condition that depends on two events. Astrogator will ignore a stopping condition until its 'before' conditions are met. Astrogator then interpolates backwards to the normal stopping condition."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_before_conditions_metadata)

    _get_inherited_metadata = { "offset" : _get_inherited_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def inherited(self) -> bool:
        """Condition Inherited by Automatic Sequences - if true, the stopping condition will be applied to any automatic sequences activated within the same segment."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_inherited_metadata)

    _set_inherited_metadata = { "offset" : _set_inherited_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @inherited.setter
    def inherited(self, value:bool) -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_inherited_metadata, value)

    _get_sequence_metadata = { "offset" : _get_sequence_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def sequence(self) -> str:
        """Get or set the automatic sequence to trigger if the highlighted stopping condition is satisfied."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_sequence_metadata)

    _set_sequence_metadata = { "offset" : _set_sequence_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @sequence.setter
    def sequence(self, value:str) -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_sequence_metadata, value)

    _get_condition_metadata = { "offset" : _get_condition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LightingCondition),) }
    @property
    def condition(self) -> "LightingCondition":
        """Specify the direction from which the stopping condition value must be achieved."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_condition_metadata)

    _set_condition_metadata = { "offset" : _set_condition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LightingCondition),) }
    @condition.setter
    def condition(self, value:"LightingCondition") -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_condition_metadata, value)

    _get_eclipsing_bodies_list_source_metadata = { "offset" : _get_eclipsing_bodies_list_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EclipsingBodiesSource),) }
    @property
    def eclipsing_bodies_list_source(self) -> "EclipsingBodiesSource":
        """Eclipsing Bodies List Source."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_eclipsing_bodies_list_source_metadata)

    _set_eclipsing_bodies_list_source_metadata = { "offset" : _set_eclipsing_bodies_list_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EclipsingBodiesSource),) }
    @eclipsing_bodies_list_source.setter
    def eclipsing_bodies_list_source(self, value:"EclipsingBodiesSource") -> None:
        return self._intf.set_property(LightingStoppingCondition._metadata, LightingStoppingCondition._set_eclipsing_bodies_list_source_metadata, value)

    _add_eclipsing_body_metadata = { "offset" : _add_eclipsing_body_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def add_eclipsing_body(self, eclipsing_body:str) -> None:
        """Add an eclipsing body."""
        return self._intf.invoke(LightingStoppingCondition._metadata, LightingStoppingCondition._add_eclipsing_body_metadata, eclipsing_body)

    _remove_eclipsing_body_metadata = { "offset" : _remove_eclipsing_body_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_eclipsing_body(self, eclipsing_body:str) -> None:
        """Remove an eclipsing body."""
        return self._intf.invoke(LightingStoppingCondition._metadata, LightingStoppingCondition._remove_eclipsing_body_metadata, eclipsing_body)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def eclipsing_bodies(self) -> list:
        """Return a list of user selected eclipsing bodies."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_eclipsing_bodies_metadata)

    _get_available_eclipsing_bodies_metadata = { "offset" : _get_available_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def available_eclipsing_bodies(self) -> list:
        """Return a list of available eclipsing bodies."""
        return self._intf.get_property(LightingStoppingCondition._metadata, LightingStoppingCondition._get_available_eclipsing_bodies_metadata)

    _property_names[max_trip_times] = "max_trip_times"
    _property_names[repeat_count] = "repeat_count"
    _property_names[constraints] = "constraints"
    _property_names[before_conditions] = "before_conditions"
    _property_names[inherited] = "inherited"
    _property_names[sequence] = "sequence"
    _property_names[condition] = "condition"
    _property_names[eclipsing_bodies_list_source] = "eclipsing_bodies_list_source"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[available_eclipsing_bodies] = "available_eclipsing_bodies"

    def __init__(self, source_object=None):
        """Construct an object of type LightingStoppingCondition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, LightingStoppingCondition)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
        IStoppingConditionComponent.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
        IStoppingConditionComponent._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, LightingStoppingCondition, [LightingStoppingCondition, IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5265280262797051925, 13545129389778936992), LightingStoppingCondition)
agcls.AgTypeNameMap["LightingStoppingCondition"] = LightingStoppingCondition

class StoppingCondition(IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Basic properties for a stopping condition."""

    _num_methods = 30
    _vtable_offset = IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods
    _get_trip_method_offset = 1
    _set_trip_method_offset = 2
    _get_tolerance_method_offset = 3
    _set_tolerance_method_offset = 4
    _get_repeat_count_method_offset = 5
    _set_repeat_count_method_offset = 6
    _get_inherited_method_offset = 7
    _set_inherited_method_offset = 8
    _get_max_trip_times_method_offset = 9
    _set_max_trip_times_method_offset = 10
    _get_coord_system_method_offset = 11
    _set_coord_system_method_offset = 12
    _get_sequence_method_offset = 13
    _set_sequence_method_offset = 14
    _get_constraints_method_offset = 15
    _get_user_calculation_object_name_method_offset = 16
    _set_user_calculation_object_name_method_offset = 17
    _get_user_calculation_object_method_offset = 18
    _set_user_calculation_object_method_offset = 19
    _get_central_body_name_method_offset = 20
    _set_central_body_name_method_offset = 21
    _get_criterion_method_offset = 22
    _set_criterion_method_offset = 23
    _get_before_conditions_method_offset = 24
    _get_dimension_method_offset = 25
    _get_reference_point_method_offset = 26
    _set_reference_point_method_offset = 27
    _copy_user_calculation_object_to_clipboard_method_offset = 28
    _paste_user_calculation_object_from_clipboard_method_offset = 29
    _get_user_calculation_object_link_embed_control_method_offset = 30
    _metadata = {
        "iid_data" : (4986301151178184009, 6721367927442663319),
        "vtable_reference" : IStoppingConditionComponent._vtable_offset + IStoppingConditionComponent._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StoppingCondition)

    _get_trip_metadata = { "offset" : _get_trip_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def trip(self) -> typing.Any:
        """Get or set the desired value - the value at which the condition will be satisfied. Dimension depends on context."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_trip_metadata)

    _set_trip_metadata = { "offset" : _set_trip_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @trip.setter
    def trip(self, value:typing.Any) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_trip_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance(self) -> float:
        """Get or set the desired tolerance for achieving the stopping condition. Dimension depends on context."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance.setter
    def tolerance(self, value:float) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_tolerance_metadata, value)

    _get_repeat_count_metadata = { "offset" : _get_repeat_count_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def repeat_count(self) -> float:
        """Get or set the number of times the condition must be satisfied before the propagation ends or moves on to the designated automatic sequence. Dimensionless."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_repeat_count_metadata)

    _set_repeat_count_metadata = { "offset" : _set_repeat_count_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @repeat_count.setter
    def repeat_count(self, value:float) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_repeat_count_metadata, value)

    _get_inherited_metadata = { "offset" : _get_inherited_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def inherited(self) -> bool:
        """Condition Inherited by Automatic Sequences - if true, the stopping condition will be applied to any automatic sequences activated within the same segment."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_inherited_metadata)

    _set_inherited_metadata = { "offset" : _set_inherited_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @inherited.setter
    def inherited(self, value:bool) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_inherited_metadata, value)

    _get_max_trip_times_metadata = { "offset" : _get_max_trip_times_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_trip_times(self) -> float:
        """Get or set the maximum number of times that the stopping condition will be applied - and any resulting automatic sequences executed. Dimensionless."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_max_trip_times_metadata)

    _set_max_trip_times_metadata = { "offset" : _set_max_trip_times_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_trip_times.setter
    def max_trip_times(self, value:float) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_max_trip_times_metadata, value)

    _get_coord_system_metadata = { "offset" : _get_coord_system_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system(self) -> str:
        """Get or set the coordinate system. The default coordinate system of a stopping condition is Earth Inertial."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_coord_system_metadata)

    _set_coord_system_metadata = { "offset" : _set_coord_system_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system.setter
    def coord_system(self, value:str) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_coord_system_metadata, value)

    _get_sequence_metadata = { "offset" : _get_sequence_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def sequence(self) -> str:
        """Get or set the automatic sequence to trigger if the highlighted stopping condition is satisfied."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_sequence_metadata)

    _set_sequence_metadata = { "offset" : _set_sequence_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @sequence.setter
    def sequence(self, value:str) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_sequence_metadata, value)

    _get_constraints_metadata = { "offset" : _get_constraints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def constraints(self) -> "ConstraintCollection":
        """Further conditions that must be met in order for the stopping condition to be deemed satisfied."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_constraints_metadata)

    _get_user_calculation_object_name_metadata = { "offset" : _get_user_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_calculation_object_name(self) -> str:
        """User Calc Object - a User Calculation Object for the highlighted stopping condition. For user-defined stopping conditions, use this field to specify what kind of value you want to stop on."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_user_calculation_object_name_metadata)

    _set_user_calculation_object_name_metadata = { "offset" : _set_user_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_calculation_object_name.setter
    def user_calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_user_calculation_object_name_metadata, value)

    _get_user_calculation_object_metadata = { "offset" : _get_user_calculation_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_calculation_object(self) -> "IComponentInfo":
        """A User Calculation Object for the highlighted stopping condition. For user-defined stopping conditions, use this field to specify what kind of value you want to stop on."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_user_calculation_object_metadata)

    _set_user_calculation_object_metadata = { "offset" : _set_user_calculation_object_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"),) }
    @user_calculation_object.setter
    def user_calculation_object(self, new_value:"IComponentInfo") -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_user_calculation_object_metadata, new_value)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body. The default central body of a stopping condition is the Earth."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_central_body_name_metadata, value)

    _get_criterion_metadata = { "offset" : _get_criterion_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Criterion),) }
    @property
    def criterion(self) -> "Criterion":
        """Specify the direction from which the stopping condition value must be achieved."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_criterion_metadata)

    _set_criterion_metadata = { "offset" : _set_criterion_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Criterion),) }
    @criterion.setter
    def criterion(self, value:"Criterion") -> None:
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_criterion_metadata, value)

    _get_before_conditions_metadata = { "offset" : _get_before_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def before_conditions(self) -> "StoppingConditionCollection":
        """A 'before' stopping condition is used to define a stopping condition that depends on two events. Astrogator will ignore a stopping condition until its 'before' conditions are met. Astrogator then interpolates backwards to the normal stopping condition."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_before_conditions_metadata)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Get the dimension of the stopping condition."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_dimension_metadata)

    _get_reference_point_metadata = { "offset" : _get_reference_point_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_point(self) -> str:
        """Get or set the reference point used for calculation."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_reference_point_metadata)

    _set_reference_point_metadata = { "offset" : _set_reference_point_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_point.setter
    def reference_point(self, value:str) -> None:
        """Get or set the reference point used for calculation."""
        return self._intf.set_property(StoppingCondition._metadata, StoppingCondition._set_reference_point_metadata, value)

    _copy_user_calculation_object_to_clipboard_metadata = { "offset" : _copy_user_calculation_object_to_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_user_calculation_object_to_clipboard(self) -> None:
        """Copy the user-defined stopping condition calc object to the clipboard."""
        return self._intf.invoke(StoppingCondition._metadata, StoppingCondition._copy_user_calculation_object_to_clipboard_metadata, )

    _paste_user_calculation_object_from_clipboard_metadata = { "offset" : _paste_user_calculation_object_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_user_calculation_object_from_clipboard(self) -> None:
        """Replace the user-defined stopping condition calc object with the calc object in the clipboard."""
        return self._intf.invoke(StoppingCondition._metadata, StoppingCondition._paste_user_calculation_object_from_clipboard_metadata, )

    _get_user_calculation_object_link_embed_control_metadata = { "offset" : _get_user_calculation_object_link_embed_control_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_calculation_object_link_embed_control(self) -> "IComponentLinkEmbedControl":
        """Get the link / embed controller for managing the user calc. object."""
        return self._intf.get_property(StoppingCondition._metadata, StoppingCondition._get_user_calculation_object_link_embed_control_metadata)

    _property_names[trip] = "trip"
    _property_names[tolerance] = "tolerance"
    _property_names[repeat_count] = "repeat_count"
    _property_names[inherited] = "inherited"
    _property_names[max_trip_times] = "max_trip_times"
    _property_names[coord_system] = "coord_system"
    _property_names[sequence] = "sequence"
    _property_names[constraints] = "constraints"
    _property_names[user_calculation_object_name] = "user_calculation_object_name"
    _property_names[user_calculation_object] = "user_calculation_object"
    _property_names[central_body_name] = "central_body_name"
    _property_names[criterion] = "criterion"
    _property_names[before_conditions] = "before_conditions"
    _property_names[dimension] = "dimension"
    _property_names[reference_point] = "reference_point"
    _property_names[user_calculation_object_link_embed_control] = "user_calculation_object_link_embed_control"

    def __init__(self, source_object=None):
        """Construct an object of type StoppingCondition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StoppingCondition)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
        IStoppingConditionComponent.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
        IStoppingConditionComponent._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StoppingCondition, [StoppingCondition, IComponentInfo, ICloneable, IStoppingConditionComponent, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5288325747025247960, 14620341470789352850), StoppingCondition)
agcls.AgTypeNameMap["StoppingCondition"] = StoppingCondition

class StoppingConditionElement(IComponentInfo, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The status of a stopping condition."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_active_method_offset = 1
    _set_active_method_offset = 2
    _enable_control_parameter_method_offset = 3
    _disable_control_parameter_method_offset = 4
    _is_control_parameter_enabled_method_offset = 5
    _get_control_parameters_available_method_offset = 6
    _get_properties_method_offset = 7
    _metadata = {
        "iid_data" : (4803961492800537644, 11540006383510258587),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StoppingConditionElement)

    _get_active_metadata = { "offset" : _get_active_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def active(self) -> bool:
        """If true, the stopping condition is active."""
        return self._intf.get_property(StoppingConditionElement._metadata, StoppingConditionElement._get_active_metadata)

    _set_active_metadata = { "offset" : _set_active_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @active.setter
    def active(self, value:bool) -> None:
        return self._intf.set_property(StoppingConditionElement._metadata, StoppingConditionElement._set_active_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlStoppingCondition),) }
    def enable_control_parameter(self, param:"ControlStoppingCondition") -> None:
        """Enable or disables the specified control parameter."""
        return self._intf.invoke(StoppingConditionElement._metadata, StoppingConditionElement._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlStoppingCondition),) }
    def disable_control_parameter(self, param:"ControlStoppingCondition") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(StoppingConditionElement._metadata, StoppingConditionElement._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlStoppingCondition), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlStoppingCondition") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(StoppingConditionElement._metadata, StoppingConditionElement._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(StoppingConditionElement._metadata, StoppingConditionElement._get_control_parameters_available_metadata)

    _get_properties_metadata = { "offset" : _get_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def properties(self) -> "IStoppingConditionComponent":
        """Get the properties available to the stopping condition."""
        return self._intf.get_property(StoppingConditionElement._metadata, StoppingConditionElement._get_properties_metadata)

    _property_names[active] = "active"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[properties] = "properties"

    def __init__(self, source_object=None):
        """Construct an object of type StoppingConditionElement."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StoppingConditionElement)
        IComponentInfo.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StoppingConditionElement, [StoppingConditionElement, IComponentInfo, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5056737663241954080, 13082724610818700691), StoppingConditionElement)
agcls.AgTypeNameMap["StoppingConditionElement"] = StoppingConditionElement

class MCSSequence(IMCSSegment, IRuntimeTypeInfoProvider, IMCSSequence, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """The Sequence segment."""
    def __init__(self, source_object=None):
        """Construct an object of type MCSSequence."""
        SupportsDeleteCallback.__init__(self)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IMCSSequence.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IMCSSequence._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSSequence, [IMCSSegment, IRuntimeTypeInfoProvider, IMCSSequence, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4728221592052087246, 17245365907217799322), MCSSequence)
agcls.AgTypeNameMap["MCSSequence"] = MCSSequence

class MCSBackwardSequence(IMCSSegment, IRuntimeTypeInfoProvider, IMCSSequence, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Backward Sequence segment."""

    _num_methods = 0
    _vtable_offset = IMCSSequence._vtable_offset + IMCSSequence._num_methods
    _metadata = {
        "iid_data" : (5647154259170389577, 17278564796132019345),
        "vtable_reference" : IMCSSequence._vtable_offset + IMCSSequence._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSBackwardSequence)


    def __init__(self, source_object=None):
        """Construct an object of type MCSBackwardSequence."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSBackwardSequence)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IMCSSequence.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IMCSSequence._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSBackwardSequence, [MCSBackwardSequence, IMCSSegment, IRuntimeTypeInfoProvider, IMCSSequence, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5483461179733130724, 18354047637942609031), MCSBackwardSequence)
agcls.AgTypeNameMap["MCSBackwardSequence"] = MCSBackwardSequence

class MCSLaunch(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Launch segment."""

    _num_methods = 32
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_step_size_method_offset = 3
    _set_step_size_method_offset = 4
    _get_pre_launch_time_method_offset = 5
    _set_pre_launch_time_method_offset = 6
    _get_epoch_method_offset = 7
    _set_epoch_method_offset = 8
    _enable_control_parameter_method_offset = 9
    _disable_control_parameter_method_offset = 10
    _is_control_parameter_enabled_method_offset = 11
    _get_control_parameters_available_method_offset = 12
    _get_initial_acceleration_method_offset = 13
    _set_initial_acceleration_method_offset = 14
    _get_spacecraft_parameters_method_offset = 15
    _get_fuel_tank_method_offset = 16
    _get_display_system_type_method_offset = 17
    _set_display_system_type_method_offset = 18
    _get_display_system_method_offset = 19
    _get_ascent_type_method_offset = 20
    _set_ascent_type_method_offset = 21
    _get_time_of_flight_method_offset = 22
    _set_time_of_flight_method_offset = 23
    _get_burnout_type_method_offset = 24
    _set_burnout_type_method_offset = 25
    _get_burnout_method_offset = 26
    _get_burnout_velocity_method_offset = 27
    _get_use_previous_segment_state_method_offset = 28
    _set_use_previous_segment_state_method_offset = 29
    _get_set_mission_elapsed_time_epoch_method_offset = 30
    _set_set_mission_elapsed_time_epoch_method_offset = 31
    _get_user_variables_method_offset = 32
    _metadata = {
        "iid_data" : (5629359826497880460, 7376461998916133763),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSLaunch)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_central_body_name_metadata, value)

    _get_step_size_metadata = { "offset" : _get_step_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def step_size(self) -> float:
        """Get or set the time interval between calculated ephemeris output points. Uses Time Dimension."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_step_size_metadata)

    _set_step_size_metadata = { "offset" : _set_step_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @step_size.setter
    def step_size(self, value:float) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_step_size_metadata, value)

    _get_pre_launch_time_metadata = { "offset" : _get_pre_launch_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def pre_launch_time(self) -> float:
        """Get or set the amount of time before the spacecraft's launch that it will be created in the scenario. The vehicle will remain at the launch position until beginning of the launch epoch. Uses Time Dimension."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_pre_launch_time_metadata)

    _set_pre_launch_time_metadata = { "offset" : _set_pre_launch_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @pre_launch_time.setter
    def pre_launch_time(self, value:float) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_pre_launch_time_metadata, value)

    _get_epoch_metadata = { "offset" : _get_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def epoch(self) -> typing.Any:
        """Get or set the date and time of the launch. Uses DateFormat Dimension."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_epoch_metadata)

    _set_epoch_metadata = { "offset" : _set_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @epoch.setter
    def epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_epoch_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlLaunch),) }
    def enable_control_parameter(self, param:"ControlLaunch") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(MCSLaunch._metadata, MCSLaunch._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlLaunch),) }
    def disable_control_parameter(self, param:"ControlLaunch") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSLaunch._metadata, MCSLaunch._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlLaunch), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlLaunch") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSLaunch._metadata, MCSLaunch._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_control_parameters_available_metadata)

    _get_initial_acceleration_metadata = { "offset" : _get_initial_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_acceleration(self) -> float:
        """Get or set the initial acceleration, for the Quartic Motion Ascent Type. Uses Acceleration Dimension."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_initial_acceleration_metadata)

    _set_initial_acceleration_metadata = { "offset" : _set_initial_acceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_acceleration.setter
    def initial_acceleration(self, value:float) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_initial_acceleration_metadata, value)

    _get_spacecraft_parameters_metadata = { "offset" : _get_spacecraft_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def spacecraft_parameters(self) -> "SpacecraftParameters":
        """Satellite Properties - the spacecraft's physical properties."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_spacecraft_parameters_metadata)

    _get_fuel_tank_metadata = { "offset" : _get_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_tank(self) -> "FuelTank":
        """Get the spacecraft's fuel tank properties."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_fuel_tank_metadata)

    _get_display_system_type_metadata = { "offset" : _get_display_system_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LaunchDisplaySystem),) }
    @property
    def display_system_type(self) -> "LaunchDisplaySystem":
        """Get the launch coordinate type."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_display_system_type_metadata)

    _set_display_system_type_metadata = { "offset" : _set_display_system_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LaunchDisplaySystem),) }
    def set_display_system_type(self, display_system_type:"LaunchDisplaySystem") -> None:
        """Set the display system type."""
        return self._intf.invoke(MCSLaunch._metadata, MCSLaunch._set_display_system_type_metadata, display_system_type)

    _get_display_system_metadata = { "offset" : _get_display_system_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def display_system(self) -> "IDisplaySystem":
        """Get the current Display System."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_display_system_metadata)

    _get_ascent_type_metadata = { "offset" : _get_ascent_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AscentType),) }
    @property
    def ascent_type(self) -> "AscentType":
        """Get or set the order of the spline used to generate the motion along the ellipse."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_ascent_type_metadata)

    _set_ascent_type_metadata = { "offset" : _set_ascent_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AscentType),) }
    @ascent_type.setter
    def ascent_type(self, value:"AscentType") -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_ascent_type_metadata, value)

    _get_time_of_flight_metadata = { "offset" : _get_time_of_flight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_of_flight(self) -> float:
        """Get or set the time of flight (the time from launch to burnout). Uses Time Dimension."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_time_of_flight_metadata)

    _set_time_of_flight_metadata = { "offset" : _set_time_of_flight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_of_flight.setter
    def time_of_flight(self, value:float) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_time_of_flight_metadata, value)

    _get_burnout_type_metadata = { "offset" : _get_burnout_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BurnoutType),) }
    @property
    def burnout_type(self) -> "BurnoutType":
        """Get the burnout type."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_burnout_type_metadata)

    _set_burnout_type_metadata = { "offset" : _set_burnout_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BurnoutType),) }
    def set_burnout_type(self, burnout_type:"BurnoutType") -> None:
        """Set the burnout type."""
        return self._intf.invoke(MCSLaunch._metadata, MCSLaunch._set_burnout_type_metadata, burnout_type)

    _get_burnout_metadata = { "offset" : _get_burnout_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def burnout(self) -> "IBurnout":
        """Get the burnout point definition."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_burnout_metadata)

    _get_burnout_velocity_metadata = { "offset" : _get_burnout_velocity_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def burnout_velocity(self) -> "BurnoutVelocity":
        """Get the burnout velocity definition."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_burnout_velocity_metadata)

    _get_use_previous_segment_state_metadata = { "offset" : _get_use_previous_segment_state_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_previous_segment_state(self) -> bool:
        """If true, the previous segment state is used to define the launch location parameters."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_use_previous_segment_state_metadata)

    _set_use_previous_segment_state_metadata = { "offset" : _set_use_previous_segment_state_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_previous_segment_state.setter
    def use_previous_segment_state(self, value:bool) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_use_previous_segment_state_metadata, value)

    _get_set_mission_elapsed_time_epoch_metadata = { "offset" : _get_set_mission_elapsed_time_epoch_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def set_mission_elapsed_time_epoch(self) -> bool:
        """If true, the Mission Elapsed Time epoch will be set to the launch epoch."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_set_mission_elapsed_time_epoch_metadata)

    _set_set_mission_elapsed_time_epoch_metadata = { "offset" : _set_set_mission_elapsed_time_epoch_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @set_mission_elapsed_time_epoch.setter
    def set_mission_elapsed_time_epoch(self, value:bool) -> None:
        return self._intf.set_property(MCSLaunch._metadata, MCSLaunch._set_set_mission_elapsed_time_epoch_metadata, value)

    _get_user_variables_metadata = { "offset" : _get_user_variables_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_variables(self) -> "UserVariableCollection":
        """Interface used to modify user variables for the launch segment."""
        return self._intf.get_property(MCSLaunch._metadata, MCSLaunch._get_user_variables_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[step_size] = "step_size"
    _property_names[pre_launch_time] = "pre_launch_time"
    _property_names[epoch] = "epoch"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[initial_acceleration] = "initial_acceleration"
    _property_names[spacecraft_parameters] = "spacecraft_parameters"
    _property_names[fuel_tank] = "fuel_tank"
    _property_names[display_system_type] = "display_system_type"
    _property_names[display_system] = "display_system"
    _property_names[ascent_type] = "ascent_type"
    _property_names[time_of_flight] = "time_of_flight"
    _property_names[burnout_type] = "burnout_type"
    _property_names[burnout] = "burnout"
    _property_names[burnout_velocity] = "burnout_velocity"
    _property_names[use_previous_segment_state] = "use_previous_segment_state"
    _property_names[set_mission_elapsed_time_epoch] = "set_mission_elapsed_time_epoch"
    _property_names[user_variables] = "user_variables"

    def __init__(self, source_object=None):
        """Construct an object of type MCSLaunch."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSLaunch)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSLaunch, [MCSLaunch, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4943627088855875894, 16294750130809619880), MCSLaunch)
agcls.AgTypeNameMap["MCSLaunch"] = MCSLaunch

class DisplaySystemGeodetic(IDisplaySystem, SupportsDeleteCallback):
    """Properties for a geodetic launch coordinate system."""

    _num_methods = 6
    _vtable_offset = IDisplaySystem._vtable_offset + IDisplaySystem._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_altitude_method_offset = 5
    _set_altitude_method_offset = 6
    _metadata = {
        "iid_data" : (4956741510127523826, 11651406499667779456),
        "vtable_reference" : IDisplaySystem._vtable_offset + IDisplaySystem._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DisplaySystemGeodetic)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Get or set the latitude of the launch location. Uses Angle Dimension."""
        return self._intf.get_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Get or set the longitude of the launch location. Uses Angle Dimension."""
        return self._intf.get_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._set_longitude_metadata, value)

    _get_altitude_metadata = { "offset" : _get_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude(self) -> float:
        """Get or set the altitude of the launch location. Uses Distance Dimension."""
        return self._intf.get_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._get_altitude_metadata)

    _set_altitude_metadata = { "offset" : _set_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude.setter
    def altitude(self, value:float) -> None:
        return self._intf.set_property(DisplaySystemGeodetic._metadata, DisplaySystemGeodetic._set_altitude_metadata, value)

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[altitude] = "altitude"

    def __init__(self, source_object=None):
        """Construct an object of type DisplaySystemGeodetic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DisplaySystemGeodetic)
        IDisplaySystem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IDisplaySystem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DisplaySystemGeodetic, [DisplaySystemGeodetic, IDisplaySystem])

agcls.AgClassCatalog.add_catalog_entry((5185180578154751703, 12390255830257417611), DisplaySystemGeodetic)
agcls.AgTypeNameMap["DisplaySystemGeodetic"] = DisplaySystemGeodetic

class DisplaySystemGeocentric(IDisplaySystem, SupportsDeleteCallback):
    """Properties for a geocentric launch coordinate system."""

    _num_methods = 6
    _vtable_offset = IDisplaySystem._vtable_offset + IDisplaySystem._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_radius_method_offset = 5
    _set_radius_method_offset = 6
    _metadata = {
        "iid_data" : (5196042213365885690, 9963805608834460839),
        "vtable_reference" : IDisplaySystem._vtable_offset + IDisplaySystem._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DisplaySystemGeocentric)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Get or set the latitude of the launch location. Uses Angle Dimension."""
        return self._intf.get_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Get or set the longitude of the launch location. Uses Angle Dimension."""
        return self._intf.get_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._set_longitude_metadata, value)

    _get_radius_metadata = { "offset" : _get_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius(self) -> float:
        """Get or set the radius of the launch location. Uses Distance Dimension."""
        return self._intf.get_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._get_radius_metadata)

    _set_radius_metadata = { "offset" : _set_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius.setter
    def radius(self, value:float) -> None:
        return self._intf.set_property(DisplaySystemGeocentric._metadata, DisplaySystemGeocentric._set_radius_metadata, value)

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[radius] = "radius"

    def __init__(self, source_object=None):
        """Construct an object of type DisplaySystemGeocentric."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DisplaySystemGeocentric)
        IDisplaySystem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IDisplaySystem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DisplaySystemGeocentric, [DisplaySystemGeocentric, IDisplaySystem])

agcls.AgClassCatalog.add_catalog_entry((5504948962407842285, 6237651898638065543), DisplaySystemGeocentric)
agcls.AgTypeNameMap["DisplaySystemGeocentric"] = DisplaySystemGeocentric

class BurnoutGeodetic(IBurnout, SupportsDeleteCallback):
    """Properties for a geodetic burnout point definition."""

    _num_methods = 6
    _vtable_offset = IBurnout._vtable_offset + IBurnout._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_altitude_method_offset = 5
    _set_altitude_method_offset = 6
    _metadata = {
        "iid_data" : (5576865739894481099, 2369937294263193020),
        "vtable_reference" : IBurnout._vtable_offset + IBurnout._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutGeodetic)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Get or set the latitude of the spacecraft burnout. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutGeodetic._metadata, BurnoutGeodetic._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutGeodetic._metadata, BurnoutGeodetic._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Get or set the longitude of the spacecraft burnout. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutGeodetic._metadata, BurnoutGeodetic._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutGeodetic._metadata, BurnoutGeodetic._set_longitude_metadata, value)

    _get_altitude_metadata = { "offset" : _get_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude(self) -> float:
        """Get or set the altitude of the spacecraft burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutGeodetic._metadata, BurnoutGeodetic._get_altitude_metadata)

    _set_altitude_metadata = { "offset" : _set_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude.setter
    def altitude(self, value:float) -> None:
        return self._intf.set_property(BurnoutGeodetic._metadata, BurnoutGeodetic._set_altitude_metadata, value)

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[altitude] = "altitude"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutGeodetic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutGeodetic)
        IBurnout.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBurnout._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutGeodetic, [BurnoutGeodetic, IBurnout])

agcls.AgClassCatalog.add_catalog_entry((5539865009872503013, 8668164257717054908), BurnoutGeodetic)
agcls.AgTypeNameMap["BurnoutGeodetic"] = BurnoutGeodetic

class BurnoutCBFCartesian(IBurnout, SupportsDeleteCallback):
    """Properties for a Cartesian CBF burnout state definition."""

    _num_methods = 12
    _vtable_offset = IBurnout._vtable_offset + IBurnout._num_methods
    _get_cartesian_burnout_x_method_offset = 1
    _set_cartesian_burnout_x_method_offset = 2
    _get_cartesian_burnout_y_method_offset = 3
    _set_cartesian_burnout_y_method_offset = 4
    _get_cartesian_burnout_z_method_offset = 5
    _set_cartesian_burnout_z_method_offset = 6
    _get_cartesian_burnout_vx_method_offset = 7
    _set_cartesian_burnout_vx_method_offset = 8
    _get_cartesian_burnout_vy_method_offset = 9
    _set_cartesian_burnout_vy_method_offset = 10
    _get_cartesian_burnout_vz_method_offset = 11
    _set_cartesian_burnout_vz_method_offset = 12
    _metadata = {
        "iid_data" : (5533696357243410767, 4114781725420291000),
        "vtable_reference" : IBurnout._vtable_offset + IBurnout._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutCBFCartesian)

    _get_cartesian_burnout_x_metadata = { "offset" : _get_cartesian_burnout_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_x(self) -> float:
        """The CBF x component of the spacecraft burnout location. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_x_metadata)

    _set_cartesian_burnout_x_metadata = { "offset" : _set_cartesian_burnout_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_x.setter
    def cartesian_burnout_x(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_x_metadata, value)

    _get_cartesian_burnout_y_metadata = { "offset" : _get_cartesian_burnout_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_y(self) -> float:
        """The CBF y component of the spacecraft burnout location. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_y_metadata)

    _set_cartesian_burnout_y_metadata = { "offset" : _set_cartesian_burnout_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_y.setter
    def cartesian_burnout_y(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_y_metadata, value)

    _get_cartesian_burnout_z_metadata = { "offset" : _get_cartesian_burnout_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_z(self) -> float:
        """The CBF z component of the spacecraft burnout location. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_z_metadata)

    _set_cartesian_burnout_z_metadata = { "offset" : _set_cartesian_burnout_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_z.setter
    def cartesian_burnout_z(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_z_metadata, value)

    _get_cartesian_burnout_vx_metadata = { "offset" : _get_cartesian_burnout_vx_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_vx(self) -> float:
        """The CBF x component of the spacecraft burnout velocity. Uses Rate Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_vx_metadata)

    _set_cartesian_burnout_vx_metadata = { "offset" : _set_cartesian_burnout_vx_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_vx.setter
    def cartesian_burnout_vx(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_vx_metadata, value)

    _get_cartesian_burnout_vy_metadata = { "offset" : _get_cartesian_burnout_vy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_vy(self) -> float:
        """The CBF y component of the spacecraft burnout velocity. Uses Rate Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_vy_metadata)

    _set_cartesian_burnout_vy_metadata = { "offset" : _set_cartesian_burnout_vy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_vy.setter
    def cartesian_burnout_vy(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_vy_metadata, value)

    _get_cartesian_burnout_vz_metadata = { "offset" : _get_cartesian_burnout_vz_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cartesian_burnout_vz(self) -> float:
        """The CBF z component of the spacecraft burnout velocity. Uses Rate Dimension."""
        return self._intf.get_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._get_cartesian_burnout_vz_metadata)

    _set_cartesian_burnout_vz_metadata = { "offset" : _set_cartesian_burnout_vz_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cartesian_burnout_vz.setter
    def cartesian_burnout_vz(self, value:float) -> None:
        return self._intf.set_property(BurnoutCBFCartesian._metadata, BurnoutCBFCartesian._set_cartesian_burnout_vz_metadata, value)

    _property_names[cartesian_burnout_x] = "cartesian_burnout_x"
    _property_names[cartesian_burnout_y] = "cartesian_burnout_y"
    _property_names[cartesian_burnout_z] = "cartesian_burnout_z"
    _property_names[cartesian_burnout_vx] = "cartesian_burnout_vx"
    _property_names[cartesian_burnout_vy] = "cartesian_burnout_vy"
    _property_names[cartesian_burnout_vz] = "cartesian_burnout_vz"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutCBFCartesian."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutCBFCartesian)
        IBurnout.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBurnout._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutCBFCartesian, [BurnoutCBFCartesian, IBurnout])

agcls.AgClassCatalog.add_catalog_entry((5317169324524563753, 10355185014748398739), BurnoutCBFCartesian)
agcls.AgTypeNameMap["BurnoutCBFCartesian"] = BurnoutCBFCartesian

class BurnoutGeocentric(IBurnout, SupportsDeleteCallback):
    """{Properties for a geocentric burnout point definition."""

    _num_methods = 6
    _vtable_offset = IBurnout._vtable_offset + IBurnout._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_radius_method_offset = 5
    _set_radius_method_offset = 6
    _metadata = {
        "iid_data" : (5762718672652749616, 7859120436857445764),
        "vtable_reference" : IBurnout._vtable_offset + IBurnout._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutGeocentric)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def latitude(self) -> typing.Any:
        """Get or set the latitude of the spacecraft burnout. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutGeocentric._metadata, BurnoutGeocentric._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @latitude.setter
    def latitude(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutGeocentric._metadata, BurnoutGeocentric._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def longitude(self) -> typing.Any:
        """Get or set the longitude of the spacecraft burnout. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutGeocentric._metadata, BurnoutGeocentric._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @longitude.setter
    def longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutGeocentric._metadata, BurnoutGeocentric._set_longitude_metadata, value)

    _get_radius_metadata = { "offset" : _get_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius(self) -> float:
        """Get or set the radius of the spacecraft burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutGeocentric._metadata, BurnoutGeocentric._get_radius_metadata)

    _set_radius_metadata = { "offset" : _set_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius.setter
    def radius(self, value:float) -> None:
        return self._intf.set_property(BurnoutGeocentric._metadata, BurnoutGeocentric._set_radius_metadata, value)

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[radius] = "radius"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutGeocentric."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutGeocentric)
        IBurnout.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBurnout._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutGeocentric, [BurnoutGeocentric, IBurnout])

agcls.AgClassCatalog.add_catalog_entry((5595051361256152931, 155232765662894480), BurnoutGeocentric)
agcls.AgTypeNameMap["BurnoutGeocentric"] = BurnoutGeocentric

class BurnoutLaunchAzAltitude(IBurnout, SupportsDeleteCallback):
    """Properties for a launch azimuth / altitude burnout point definition."""

    _num_methods = 6
    _vtable_offset = IBurnout._vtable_offset + IBurnout._num_methods
    _get_azimuth_method_offset = 1
    _set_azimuth_method_offset = 2
    _get_down_range_dist_method_offset = 3
    _set_down_range_dist_method_offset = 4
    _get_altitude_radius_method_offset = 5
    _set_altitude_radius_method_offset = 6
    _metadata = {
        "iid_data" : (5725841762349009839, 190320382121745067),
        "vtable_reference" : IBurnout._vtable_offset + IBurnout._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutLaunchAzAltitude)

    _get_azimuth_metadata = { "offset" : _get_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def azimuth(self) -> typing.Any:
        """Get or set the azimuth of the launch trajectory. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._get_azimuth_metadata)

    _set_azimuth_metadata = { "offset" : _set_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @azimuth.setter
    def azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._set_azimuth_metadata, value)

    _get_down_range_dist_metadata = { "offset" : _get_down_range_dist_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def down_range_dist(self) -> float:
        """Get or set the downrange distance of the spacecraft from launch at burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._get_down_range_dist_metadata)

    _set_down_range_dist_metadata = { "offset" : _set_down_range_dist_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @down_range_dist.setter
    def down_range_dist(self, value:float) -> None:
        return self._intf.set_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._set_down_range_dist_metadata, value)

    _get_altitude_radius_metadata = { "offset" : _get_altitude_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_radius(self) -> float:
        """Get or set the altitude of the spacecraft at burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._get_altitude_radius_metadata)

    _set_altitude_radius_metadata = { "offset" : _set_altitude_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_radius.setter
    def altitude_radius(self, value:float) -> None:
        return self._intf.set_property(BurnoutLaunchAzAltitude._metadata, BurnoutLaunchAzAltitude._set_altitude_radius_metadata, value)

    _property_names[azimuth] = "azimuth"
    _property_names[down_range_dist] = "down_range_dist"
    _property_names[altitude_radius] = "altitude_radius"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutLaunchAzAltitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutLaunchAzAltitude)
        IBurnout.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBurnout._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutLaunchAzAltitude, [BurnoutLaunchAzAltitude, IBurnout])

agcls.AgClassCatalog.add_catalog_entry((5762357320506376366, 9632671212585029549), BurnoutLaunchAzAltitude)
agcls.AgTypeNameMap["BurnoutLaunchAzAltitude"] = BurnoutLaunchAzAltitude

class BurnoutLaunchAzRadius(IBurnout, SupportsDeleteCallback):
    """Properties for a launch azimuth / radius burnout point definition."""

    _num_methods = 6
    _vtable_offset = IBurnout._vtable_offset + IBurnout._num_methods
    _get_azimuth_method_offset = 1
    _set_azimuth_method_offset = 2
    _get_down_range_dist_method_offset = 3
    _set_down_range_dist_method_offset = 4
    _get_radius_method_offset = 5
    _set_radius_method_offset = 6
    _metadata = {
        "iid_data" : (5453106663533698568, 1463398942728011174),
        "vtable_reference" : IBurnout._vtable_offset + IBurnout._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutLaunchAzRadius)

    _get_azimuth_metadata = { "offset" : _get_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def azimuth(self) -> typing.Any:
        """Get or set the azimuth of the launch trajectory. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._get_azimuth_metadata)

    _set_azimuth_metadata = { "offset" : _set_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @azimuth.setter
    def azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._set_azimuth_metadata, value)

    _get_down_range_dist_metadata = { "offset" : _get_down_range_dist_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def down_range_dist(self) -> float:
        """Get or set the downrange distance of the spacecraft from launch at burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._get_down_range_dist_metadata)

    _set_down_range_dist_metadata = { "offset" : _set_down_range_dist_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @down_range_dist.setter
    def down_range_dist(self, value:float) -> None:
        return self._intf.set_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._set_down_range_dist_metadata, value)

    _get_radius_metadata = { "offset" : _get_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius(self) -> float:
        """Get or set the radius of the spacecraft at burnout. Uses Distance Dimension."""
        return self._intf.get_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._get_radius_metadata)

    _set_radius_metadata = { "offset" : _set_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius.setter
    def radius(self, value:float) -> None:
        return self._intf.set_property(BurnoutLaunchAzRadius._metadata, BurnoutLaunchAzRadius._set_radius_metadata, value)

    _property_names[azimuth] = "azimuth"
    _property_names[down_range_dist] = "down_range_dist"
    _property_names[radius] = "radius"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutLaunchAzRadius."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutLaunchAzRadius)
        IBurnout.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBurnout._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutLaunchAzRadius, [BurnoutLaunchAzRadius, IBurnout])

agcls.AgClassCatalog.add_catalog_entry((4790898737235059150, 10276049878661454781), BurnoutLaunchAzRadius)
agcls.AgTypeNameMap["BurnoutLaunchAzRadius"] = BurnoutLaunchAzRadius

class BurnoutVelocity(SupportsDeleteCallback):
    """Properties for the burnout velocity of a Launch segment."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_burnout_option_method_offset = 1
    _set_burnout_option_method_offset = 2
    _get_fixed_velocity_method_offset = 3
    _set_fixed_velocity_method_offset = 4
    _get_inertial_velocity_method_offset = 5
    _set_inertial_velocity_method_offset = 6
    _get_inertial_velocity_azimuth_method_offset = 7
    _set_inertial_velocity_azimuth_method_offset = 8
    _get_inertial_horizontal_flight_path_angle_method_offset = 9
    _set_inertial_horizontal_flight_path_angle_method_offset = 10
    _metadata = {
        "iid_data" : (4907025633322372581, 16846539782637522584),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BurnoutVelocity)

    _get_burnout_option_metadata = { "offset" : _get_burnout_option_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BurnoutOptions),) }
    @property
    def burnout_option(self) -> "BurnoutOptions":
        """Select to use the fixed or inertial frame."""
        return self._intf.get_property(BurnoutVelocity._metadata, BurnoutVelocity._get_burnout_option_metadata)

    _set_burnout_option_metadata = { "offset" : _set_burnout_option_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BurnoutOptions),) }
    @burnout_option.setter
    def burnout_option(self, value:"BurnoutOptions") -> None:
        return self._intf.set_property(BurnoutVelocity._metadata, BurnoutVelocity._set_burnout_option_metadata, value)

    _get_fixed_velocity_metadata = { "offset" : _get_fixed_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fixed_velocity(self) -> float:
        """Get or set the velocity magnitude . Uses Rate Dimension."""
        return self._intf.get_property(BurnoutVelocity._metadata, BurnoutVelocity._get_fixed_velocity_metadata)

    _set_fixed_velocity_metadata = { "offset" : _set_fixed_velocity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fixed_velocity.setter
    def fixed_velocity(self, value:float) -> None:
        return self._intf.set_property(BurnoutVelocity._metadata, BurnoutVelocity._set_fixed_velocity_metadata, value)

    _get_inertial_velocity_metadata = { "offset" : _get_inertial_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def inertial_velocity(self) -> float:
        """Get or set the velocity magnitude. Uses Rate Dimension."""
        return self._intf.get_property(BurnoutVelocity._metadata, BurnoutVelocity._get_inertial_velocity_metadata)

    _set_inertial_velocity_metadata = { "offset" : _set_inertial_velocity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @inertial_velocity.setter
    def inertial_velocity(self, value:float) -> None:
        return self._intf.set_property(BurnoutVelocity._metadata, BurnoutVelocity._set_inertial_velocity_metadata, value)

    _get_inertial_velocity_azimuth_metadata = { "offset" : _get_inertial_velocity_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inertial_velocity_azimuth(self) -> typing.Any:
        """Get or set the inertial velocity azimuth. Inertial velocity azimuth is the angle from the projection of north in the local horizontal plane to the inertial velocity vector, right handed. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutVelocity._metadata, BurnoutVelocity._get_inertial_velocity_azimuth_metadata)

    _set_inertial_velocity_azimuth_metadata = { "offset" : _set_inertial_velocity_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inertial_velocity_azimuth.setter
    def inertial_velocity_azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutVelocity._metadata, BurnoutVelocity._set_inertial_velocity_azimuth_metadata, value)

    _get_inertial_horizontal_flight_path_angle_metadata = { "offset" : _get_inertial_horizontal_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inertial_horizontal_flight_path_angle(self) -> typing.Any:
        """Inertial horizontal flight path angle is the angle from the local horizontal to the inertial velocity vector, positive towards radius. It is also 90 degrees minus vertical flight path angle. Uses Angle Dimension."""
        return self._intf.get_property(BurnoutVelocity._metadata, BurnoutVelocity._get_inertial_horizontal_flight_path_angle_metadata)

    _set_inertial_horizontal_flight_path_angle_metadata = { "offset" : _set_inertial_horizontal_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inertial_horizontal_flight_path_angle.setter
    def inertial_horizontal_flight_path_angle(self, value:typing.Any) -> None:
        return self._intf.set_property(BurnoutVelocity._metadata, BurnoutVelocity._set_inertial_horizontal_flight_path_angle_metadata, value)

    _property_names[burnout_option] = "burnout_option"
    _property_names[fixed_velocity] = "fixed_velocity"
    _property_names[inertial_velocity] = "inertial_velocity"
    _property_names[inertial_velocity_azimuth] = "inertial_velocity_azimuth"
    _property_names[inertial_horizontal_flight_path_angle] = "inertial_horizontal_flight_path_angle"

    def __init__(self, source_object=None):
        """Construct an object of type BurnoutVelocity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BurnoutVelocity)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BurnoutVelocity, [BurnoutVelocity, ])

agcls.AgClassCatalog.add_catalog_entry((5357386615005395369, 9502758749122036118), BurnoutVelocity)
agcls.AgTypeNameMap["BurnoutVelocity"] = BurnoutVelocity

class MCSFollow(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Follow segment."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_leader_method_offset = 1
    _get_x_offset_method_offset = 2
    _set_x_offset_method_offset = 3
    _get_y_offset_method_offset = 4
    _set_y_offset_method_offset = 5
    _get_z_offset_method_offset = 6
    _set_z_offset_method_offset = 7
    _get_separation_conditions_method_offset = 8
    _get_spacecraft_parameters_method_offset = 9
    _get_fuel_tank_method_offset = 10
    _get_joining_type_method_offset = 11
    _set_joining_type_method_offset = 12
    _get_separation_type_method_offset = 13
    _set_separation_type_method_offset = 14
    _get_spacecraft_and_fuel_tank_type_method_offset = 15
    _set_spacecraft_and_fuel_tank_type_method_offset = 16
    _get_joining_conditions_method_offset = 17
    _enable_control_parameter_method_offset = 18
    _disable_control_parameter_method_offset = 19
    _is_control_parameter_enabled_method_offset = 20
    _get_control_parameters_available_method_offset = 21
    _get_user_variables_method_offset = 22
    _metadata = {
        "iid_data" : (5434070931037272692, 14909867834553447813),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSFollow)

    _get_leader_metadata = { "offset" : _get_leader_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def leader(self) -> "ILinkToObject":
        """Get the leader object."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_leader_metadata)

    _get_x_offset_metadata = { "offset" : _get_x_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def x_offset(self) -> float:
        """Get or set the distance that the spacecraft will be offset from the leader's body frame along the X axis. Uses Distance Dimension."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_x_offset_metadata)

    _set_x_offset_metadata = { "offset" : _set_x_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @x_offset.setter
    def x_offset(self, value:float) -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_x_offset_metadata, value)

    _get_y_offset_metadata = { "offset" : _get_y_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y_offset(self) -> float:
        """Get or set the distance that the spacecraft will be offset from the leader's body frame along the Y axis. Uses Distance Dimension."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_y_offset_metadata)

    _set_y_offset_metadata = { "offset" : _set_y_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y_offset.setter
    def y_offset(self, value:float) -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_y_offset_metadata, value)

    _get_z_offset_metadata = { "offset" : _get_z_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def z_offset(self) -> float:
        """Get or set the distance that the spacecraft will be offset from the leader's body frame along the Z axis. Uses Distance Dimension."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_z_offset_metadata)

    _set_z_offset_metadata = { "offset" : _set_z_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @z_offset.setter
    def z_offset(self, value:float) -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_z_offset_metadata, value)

    _get_separation_conditions_metadata = { "offset" : _get_separation_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def separation_conditions(self) -> "StoppingConditionCollection":
        """If separation conditions are specified, the list of separation conditions."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_separation_conditions_metadata)

    _get_spacecraft_parameters_metadata = { "offset" : _get_spacecraft_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def spacecraft_parameters(self) -> "SpacecraftParameters":
        """Get the spacecraft's physical properties."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_spacecraft_parameters_metadata)

    _get_fuel_tank_metadata = { "offset" : _get_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_tank(self) -> "FuelTank":
        """Get the spacecraft's fuel tank properties."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_fuel_tank_metadata)

    _get_joining_type_metadata = { "offset" : _get_joining_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FollowJoin),) }
    @property
    def joining_type(self) -> "FollowJoin":
        """Get or set the joining type."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_joining_type_metadata)

    _set_joining_type_metadata = { "offset" : _set_joining_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FollowJoin),) }
    @joining_type.setter
    def joining_type(self, value:"FollowJoin") -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_joining_type_metadata, value)

    _get_separation_type_metadata = { "offset" : _get_separation_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FollowSeparation),) }
    @property
    def separation_type(self) -> "FollowSeparation":
        """Get or set the separation type."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_separation_type_metadata)

    _set_separation_type_metadata = { "offset" : _set_separation_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FollowSeparation),) }
    @separation_type.setter
    def separation_type(self, value:"FollowSeparation") -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_separation_type_metadata, value)

    _get_spacecraft_and_fuel_tank_type_metadata = { "offset" : _get_spacecraft_and_fuel_tank_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FollowSpacecraftAndFuelTank),) }
    @property
    def spacecraft_and_fuel_tank_type(self) -> "FollowSpacecraftAndFuelTank":
        """Get or set the spacecraft snd fuel tank configuration type."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_spacecraft_and_fuel_tank_type_metadata)

    _set_spacecraft_and_fuel_tank_type_metadata = { "offset" : _set_spacecraft_and_fuel_tank_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FollowSpacecraftAndFuelTank),) }
    @spacecraft_and_fuel_tank_type.setter
    def spacecraft_and_fuel_tank_type(self, value:"FollowSpacecraftAndFuelTank") -> None:
        return self._intf.set_property(MCSFollow._metadata, MCSFollow._set_spacecraft_and_fuel_tank_type_metadata, value)

    _get_joining_conditions_metadata = { "offset" : _get_joining_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def joining_conditions(self) -> "StoppingConditionCollection":
        """If joining conditions are specified, the list of joining conditions."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_joining_conditions_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlFollow),) }
    def enable_control_parameter(self, param:"ControlFollow") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(MCSFollow._metadata, MCSFollow._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlFollow),) }
    def disable_control_parameter(self, param:"ControlFollow") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSFollow._metadata, MCSFollow._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlFollow), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlFollow") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSFollow._metadata, MCSFollow._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_control_parameters_available_metadata)

    _get_user_variables_metadata = { "offset" : _get_user_variables_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_variables(self) -> "UserVariableCollection":
        """Interface used to modify user variables for the follow segment."""
        return self._intf.get_property(MCSFollow._metadata, MCSFollow._get_user_variables_metadata)

    _property_names[leader] = "leader"
    _property_names[x_offset] = "x_offset"
    _property_names[y_offset] = "y_offset"
    _property_names[z_offset] = "z_offset"
    _property_names[separation_conditions] = "separation_conditions"
    _property_names[spacecraft_parameters] = "spacecraft_parameters"
    _property_names[fuel_tank] = "fuel_tank"
    _property_names[joining_type] = "joining_type"
    _property_names[separation_type] = "separation_type"
    _property_names[spacecraft_and_fuel_tank_type] = "spacecraft_and_fuel_tank_type"
    _property_names[joining_conditions] = "joining_conditions"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[user_variables] = "user_variables"

    def __init__(self, source_object=None):
        """Construct an object of type MCSFollow."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSFollow)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSFollow, [MCSFollow, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4651089075740067830, 16957833940556717219), MCSFollow)
agcls.AgTypeNameMap["MCSFollow"] = MCSFollow

class MCSManeuver(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """General properties for a Maneuver segment."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_maneuver_type_method_offset = 1
    _set_maneuver_type_method_offset = 2
    _get_maneuver_method_offset = 3
    _enable_control_parameter_method_offset = 4
    _disable_control_parameter_method_offset = 5
    _is_control_parameter_enabled_method_offset = 6
    _get_control_parameters_available_method_offset = 7
    _metadata = {
        "iid_data" : (5274901131733017230, 16553439757625640619),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSManeuver)

    _get_maneuver_type_metadata = { "offset" : _get_maneuver_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ManeuverType),) }
    @property
    def maneuver_type(self) -> "ManeuverType":
        """Get the maneuver type."""
        return self._intf.get_property(MCSManeuver._metadata, MCSManeuver._get_maneuver_type_metadata)

    _set_maneuver_type_metadata = { "offset" : _set_maneuver_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ManeuverType),) }
    def set_maneuver_type(self, maneuver_type:"ManeuverType") -> None:
        """Set the maneuver type."""
        return self._intf.invoke(MCSManeuver._metadata, MCSManeuver._set_maneuver_type_metadata, maneuver_type)

    _get_maneuver_metadata = { "offset" : _get_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def maneuver(self) -> "IManeuver":
        """Get the Maneuver properties."""
        return self._intf.get_property(MCSManeuver._metadata, MCSManeuver._get_maneuver_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlManeuver),) }
    def enable_control_parameter(self, param:"ControlManeuver") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(MCSManeuver._metadata, MCSManeuver._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlManeuver),) }
    def disable_control_parameter(self, param:"ControlManeuver") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSManeuver._metadata, MCSManeuver._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlManeuver), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlManeuver") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSManeuver._metadata, MCSManeuver._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSManeuver._metadata, MCSManeuver._get_control_parameters_available_metadata)

    _property_names[maneuver_type] = "maneuver_type"
    _property_names[maneuver] = "maneuver"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type MCSManeuver."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSManeuver)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSManeuver, [MCSManeuver, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5197336180196135168, 17213101951654587804), MCSManeuver)
agcls.AgTypeNameMap["MCSManeuver"] = MCSManeuver

class ManeuverFinite(IManeuver, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Engine properties for a Finite Maneuver."""

    _num_methods = 7
    _vtable_offset = IManeuver._vtable_offset + IManeuver._num_methods
    _get_pressure_mode_method_offset = 1
    _set_pressure_mode_method_offset = 2
    _get_thrust_efficiency_method_offset = 3
    _set_thrust_efficiency_method_offset = 4
    _get_thrust_efficiency_mode_method_offset = 5
    _set_thrust_efficiency_mode_method_offset = 6
    _get_propagator_method_offset = 7
    _metadata = {
        "iid_data" : (5217603186191275445, 13780017606388512913),
        "vtable_reference" : IManeuver._vtable_offset + IManeuver._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverFinite)

    _get_pressure_mode_metadata = { "offset" : _get_pressure_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PressureMode),) }
    @property
    def pressure_mode(self) -> "PressureMode":
        """Get or set the pressure mode."""
        return self._intf.get_property(ManeuverFinite._metadata, ManeuverFinite._get_pressure_mode_metadata)

    _set_pressure_mode_metadata = { "offset" : _set_pressure_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PressureMode),) }
    @pressure_mode.setter
    def pressure_mode(self, value:"PressureMode") -> None:
        return self._intf.set_property(ManeuverFinite._metadata, ManeuverFinite._set_pressure_mode_metadata, value)

    _get_thrust_efficiency_metadata = { "offset" : _get_thrust_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def thrust_efficiency(self) -> float:
        """Get or set the thrust efficiency value. Any number above zero is valid, with typical values around 0.98 to 1.02. Dimensionless."""
        return self._intf.get_property(ManeuverFinite._metadata, ManeuverFinite._get_thrust_efficiency_metadata)

    _set_thrust_efficiency_metadata = { "offset" : _set_thrust_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @thrust_efficiency.setter
    def thrust_efficiency(self, value:float) -> None:
        return self._intf.set_property(ManeuverFinite._metadata, ManeuverFinite._set_thrust_efficiency_metadata, value)

    _get_thrust_efficiency_mode_metadata = { "offset" : _get_thrust_efficiency_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ThrustType),) }
    @property
    def thrust_efficiency_mode(self) -> "ThrustType":
        """Thrust - the calculations that are effected by the thrust efficiency value."""
        return self._intf.get_property(ManeuverFinite._metadata, ManeuverFinite._get_thrust_efficiency_mode_metadata)

    _set_thrust_efficiency_mode_metadata = { "offset" : _set_thrust_efficiency_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ThrustType),) }
    @thrust_efficiency_mode.setter
    def thrust_efficiency_mode(self, value:"ThrustType") -> None:
        return self._intf.set_property(ManeuverFinite._metadata, ManeuverFinite._set_thrust_efficiency_mode_metadata, value)

    _get_propagator_metadata = { "offset" : _get_propagator_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propagator(self) -> "ManeuverFinitePropagator":
        """Get the propagator."""
        return self._intf.get_property(ManeuverFinite._metadata, ManeuverFinite._get_propagator_metadata)

    _property_names[pressure_mode] = "pressure_mode"
    _property_names[thrust_efficiency] = "thrust_efficiency"
    _property_names[thrust_efficiency_mode] = "thrust_efficiency_mode"
    _property_names[propagator] = "propagator"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverFinite."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverFinite)
        IManeuver.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IManeuver._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverFinite, [ManeuverFinite, IManeuver, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5240610333708177546, 2799450710697962646), ManeuverFinite)
agcls.AgTypeNameMap["ManeuverFinite"] = ManeuverFinite

class ManeuverImpulsive(IManeuver, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for an Impulsive Maneuver."""

    _num_methods = 2
    _vtable_offset = IManeuver._vtable_offset + IManeuver._num_methods
    _get_update_mass_method_offset = 1
    _set_update_mass_method_offset = 2
    _metadata = {
        "iid_data" : (4750637454318981908, 11599245637405498752),
        "vtable_reference" : IManeuver._vtable_offset + IManeuver._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverImpulsive)

    _get_update_mass_metadata = { "offset" : _get_update_mass_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def update_mass(self) -> bool:
        """True if the mass of the spacecraft will be updated on the basis of fuel usage."""
        return self._intf.get_property(ManeuverImpulsive._metadata, ManeuverImpulsive._get_update_mass_metadata)

    _set_update_mass_metadata = { "offset" : _set_update_mass_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @update_mass.setter
    def update_mass(self, value:bool) -> None:
        return self._intf.set_property(ManeuverImpulsive._metadata, ManeuverImpulsive._set_update_mass_metadata, value)

    _property_names[update_mass] = "update_mass"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverImpulsive."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverImpulsive)
        IManeuver.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IManeuver._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverImpulsive, [ManeuverImpulsive, IManeuver, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5132300925433346245, 9116018589565227669), ManeuverImpulsive)
agcls.AgTypeNameMap["ManeuverImpulsive"] = ManeuverImpulsive

class AttitudeControlImpulsiveVelocityVector(IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Velocity Vector attitude control for an Impulsive Maneuver."""

    _num_methods = 3
    _vtable_offset = IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods
    _get_delta_v_magnitude_method_offset = 1
    _set_delta_v_magnitude_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _metadata = {
        "iid_data" : (5383729676911479635, 15831358368491906978),
        "vtable_reference" : IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlImpulsiveVelocityVector)

    _get_delta_v_magnitude_metadata = { "offset" : _get_delta_v_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delta_v_magnitude(self) -> float:
        """Get or set the size of the delta-V to be applied to the orbit along the velocity vector. Uses Rate Dimension."""
        return self._intf.get_property(AttitudeControlImpulsiveVelocityVector._metadata, AttitudeControlImpulsiveVelocityVector._get_delta_v_magnitude_metadata)

    _set_delta_v_magnitude_metadata = { "offset" : _set_delta_v_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delta_v_magnitude.setter
    def delta_v_magnitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveVelocityVector._metadata, AttitudeControlImpulsiveVelocityVector._set_delta_v_magnitude_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlImpulsiveVelocityVector._metadata, AttitudeControlImpulsiveVelocityVector._get_body_constraint_vector_metadata)

    _property_names[delta_v_magnitude] = "delta_v_magnitude"
    _property_names[body_constraint_vector] = "body_constraint_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlImpulsiveVelocityVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlImpulsiveVelocityVector)
        IAttitudeControlImpulsive.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlImpulsive._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlImpulsiveVelocityVector, [AttitudeControlImpulsiveVelocityVector, IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4884403392612853562, 4746486195757777540), AttitudeControlImpulsiveVelocityVector)
agcls.AgTypeNameMap["AttitudeControlImpulsiveVelocityVector"] = AttitudeControlImpulsiveVelocityVector

class AttitudeControlImpulsiveAntiVelocityVector(IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Anti-Velocity Vector attitude control for an Impulsive Maneuver."""

    _num_methods = 3
    _vtable_offset = IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods
    _get_delta_v_magnitude_method_offset = 1
    _set_delta_v_magnitude_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _metadata = {
        "iid_data" : (5478756088215709330, 17473176637230871450),
        "vtable_reference" : IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlImpulsiveAntiVelocityVector)

    _get_delta_v_magnitude_metadata = { "offset" : _get_delta_v_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delta_v_magnitude(self) -> float:
        """Get or set the size of the delta-V to be applied to the orbit along the velocity vector. Uses Rate Dimension."""
        return self._intf.get_property(AttitudeControlImpulsiveAntiVelocityVector._metadata, AttitudeControlImpulsiveAntiVelocityVector._get_delta_v_magnitude_metadata)

    _set_delta_v_magnitude_metadata = { "offset" : _set_delta_v_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delta_v_magnitude.setter
    def delta_v_magnitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveAntiVelocityVector._metadata, AttitudeControlImpulsiveAntiVelocityVector._set_delta_v_magnitude_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlImpulsiveAntiVelocityVector._metadata, AttitudeControlImpulsiveAntiVelocityVector._get_body_constraint_vector_metadata)

    _property_names[delta_v_magnitude] = "delta_v_magnitude"
    _property_names[body_constraint_vector] = "body_constraint_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlImpulsiveAntiVelocityVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlImpulsiveAntiVelocityVector)
        IAttitudeControlImpulsive.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlImpulsive._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlImpulsiveAntiVelocityVector, [AttitudeControlImpulsiveAntiVelocityVector, IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5209788070296914908, 11656929720675121292), AttitudeControlImpulsiveAntiVelocityVector)
agcls.AgTypeNameMap["AttitudeControlImpulsiveAntiVelocityVector"] = AttitudeControlImpulsiveAntiVelocityVector

class AttitudeControlImpulsiveAttitude(IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Attitude attitude control for an Impulsive Maneuver."""

    _num_methods = 5
    _vtable_offset = IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods
    _get_delta_v_magnitude_method_offset = 1
    _set_delta_v_magnitude_method_offset = 2
    _get_reference_axes_name_method_offset = 3
    _set_reference_axes_name_method_offset = 4
    _get_orientation_method_offset = 5
    _metadata = {
        "iid_data" : (5725077979125730187, 16239998713400669345),
        "vtable_reference" : IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlImpulsiveAttitude)

    _get_delta_v_magnitude_metadata = { "offset" : _get_delta_v_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delta_v_magnitude(self) -> float:
        """Get or set the size of the delta-V to be applied along the X axis - as defined by the selected axes and rotation. Uses Rate Dimension."""
        return self._intf.get_property(AttitudeControlImpulsiveAttitude._metadata, AttitudeControlImpulsiveAttitude._get_delta_v_magnitude_metadata)

    _set_delta_v_magnitude_metadata = { "offset" : _set_delta_v_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delta_v_magnitude.setter
    def delta_v_magnitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveAttitude._metadata, AttitudeControlImpulsiveAttitude._set_delta_v_magnitude_metadata, value)

    _get_reference_axes_name_metadata = { "offset" : _get_reference_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_axes_name(self) -> str:
        """Ref Axes - the reference axes to be used in modeling this maneuver."""
        return self._intf.get_property(AttitudeControlImpulsiveAttitude._metadata, AttitudeControlImpulsiveAttitude._get_reference_axes_name_metadata)

    _set_reference_axes_name_metadata = { "offset" : _set_reference_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_axes_name.setter
    def reference_axes_name(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveAttitude._metadata, AttitudeControlImpulsiveAttitude._set_reference_axes_name_metadata, value)

    _get_orientation_metadata = { "offset" : _get_orientation_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def orientation(self) -> "IOrientation":
        """Get the orientation of the attitude."""
        return self._intf.get_property(AttitudeControlImpulsiveAttitude._metadata, AttitudeControlImpulsiveAttitude._get_orientation_metadata)

    _property_names[delta_v_magnitude] = "delta_v_magnitude"
    _property_names[reference_axes_name] = "reference_axes_name"
    _property_names[orientation] = "orientation"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlImpulsiveAttitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlImpulsiveAttitude)
        IAttitudeControlImpulsive.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlImpulsive._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlImpulsiveAttitude, [AttitudeControlImpulsiveAttitude, IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5745604571369372982, 2700112517730179510), AttitudeControlImpulsiveAttitude)
agcls.AgTypeNameMap["AttitudeControlImpulsiveAttitude"] = AttitudeControlImpulsiveAttitude

class AttitudeControlImpulsiveFile(IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the File attitude control for an Impulsive Maneuver."""

    _num_methods = 7
    _vtable_offset = IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods
    _get_delta_v_magnitude_method_offset = 1
    _set_delta_v_magnitude_method_offset = 2
    _get_filename_method_offset = 3
    _set_filename_method_offset = 4
    _get_file_time_offset_method_offset = 5
    _set_file_time_offset_method_offset = 6
    _get_full_filename_method_offset = 7
    _metadata = {
        "iid_data" : (4902519617822865926, 15504321543168614062),
        "vtable_reference" : IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlImpulsiveFile)

    _get_delta_v_magnitude_metadata = { "offset" : _get_delta_v_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def delta_v_magnitude(self) -> float:
        """Get or set the size of the delta-V to be applied to the orbit along the specified direction. Uses Rate Dimension."""
        return self._intf.get_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._get_delta_v_magnitude_metadata)

    _set_delta_v_magnitude_metadata = { "offset" : _set_delta_v_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @delta_v_magnitude.setter
    def delta_v_magnitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._set_delta_v_magnitude_metadata, value)

    _get_filename_metadata = { "offset" : _get_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filename(self) -> str:
        """Get or set the attitude file to use."""
        return self._intf.get_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._get_filename_metadata)

    _set_filename_metadata = { "offset" : _set_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @filename.setter
    def filename(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._set_filename_metadata, value)

    _get_file_time_offset_metadata = { "offset" : _get_file_time_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def file_time_offset(self) -> float:
        """Get or set the time offset can be used to adjust the time stored in the attitude file. Dimensionless."""
        return self._intf.get_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._get_file_time_offset_metadata)

    _set_file_time_offset_metadata = { "offset" : _set_file_time_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @file_time_offset.setter
    def file_time_offset(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._set_file_time_offset_metadata, value)

    _get_full_filename_metadata = { "offset" : _get_full_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def full_filename(self) -> str:
        """Get the full path and name of the attitude file to use."""
        return self._intf.get_property(AttitudeControlImpulsiveFile._metadata, AttitudeControlImpulsiveFile._get_full_filename_metadata)

    _property_names[delta_v_magnitude] = "delta_v_magnitude"
    _property_names[filename] = "filename"
    _property_names[file_time_offset] = "file_time_offset"
    _property_names[full_filename] = "full_filename"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlImpulsiveFile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlImpulsiveFile)
        IAttitudeControlImpulsive.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlImpulsive._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlImpulsiveFile, [AttitudeControlImpulsiveFile, IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5004932378358409643, 12572056464618414249), AttitudeControlImpulsiveFile)
agcls.AgTypeNameMap["AttitudeControlImpulsiveFile"] = AttitudeControlImpulsiveFile

class AttitudeControlImpulsiveThrustVector(IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Thrust Vector attitude control for an Impulsive Maneuver."""

    _num_methods = 23
    _vtable_offset = IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods
    _get_thrust_axes_name_method_offset = 1
    _set_thrust_axes_name_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _get_allow_negative_spherical_magnitude_method_offset = 4
    _set_allow_negative_spherical_magnitude_method_offset = 5
    _get_coord_type_method_offset = 6
    _set_coord_type_method_offset = 7
    _get_x_method_offset = 8
    _set_x_method_offset = 9
    _get_y_method_offset = 10
    _set_y_method_offset = 11
    _get_z_method_offset = 12
    _set_z_method_offset = 13
    _get_azimuth_method_offset = 14
    _set_azimuth_method_offset = 15
    _get_elevation_method_offset = 16
    _set_elevation_method_offset = 17
    _get_magnitude_method_offset = 18
    _set_magnitude_method_offset = 19
    _assign_cartesian_method_offset = 20
    _query_cartesian_method_offset = 21
    _assign_spherical_method_offset = 22
    _query_spherical_method_offset = 23
    _metadata = {
        "iid_data" : (5502906477986733323, 9761518986136370305),
        "vtable_reference" : IAttitudeControlImpulsive._vtable_offset + IAttitudeControlImpulsive._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlImpulsiveThrustVector)

    _get_thrust_axes_name_metadata = { "offset" : _get_thrust_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def thrust_axes_name(self) -> str:
        """Get or set the thrust axes."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_thrust_axes_name_metadata)

    _set_thrust_axes_name_metadata = { "offset" : _set_thrust_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @thrust_axes_name.setter
    def thrust_axes_name(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_thrust_axes_name_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_body_constraint_vector_metadata)

    _get_allow_negative_spherical_magnitude_metadata = { "offset" : _get_allow_negative_spherical_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def allow_negative_spherical_magnitude(self) -> bool:
        """True if the spherical magnitude should be allowed to be less than zero."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_allow_negative_spherical_magnitude_metadata)

    _set_allow_negative_spherical_magnitude_metadata = { "offset" : _set_allow_negative_spherical_magnitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @allow_negative_spherical_magnitude.setter
    def allow_negative_spherical_magnitude(self, value:bool) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_allow_negative_spherical_magnitude_metadata, value)

    _get_coord_type_metadata = { "offset" : _get_coord_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ImpulsiveDeltaVRepresentation),) }
    @property
    def coord_type(self) -> "ImpulsiveDeltaVRepresentation":
        """Get or set the coordinate representation for the DeltaV."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_coord_type_metadata)

    _set_coord_type_metadata = { "offset" : _set_coord_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ImpulsiveDeltaVRepresentation),) }
    @coord_type.setter
    def coord_type(self, value:"ImpulsiveDeltaVRepresentation") -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_coord_type_metadata, value)

    _get_x_metadata = { "offset" : _get_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def x(self) -> float:
        """Get or set the Cartesian X component of the impulsive DeltaV (dimension: SmallDistance/Time)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_x_metadata)

    _set_x_metadata = { "offset" : _set_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @x.setter
    def x(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_x_metadata, value)

    _get_y_metadata = { "offset" : _get_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y(self) -> float:
        """Get or set the Cartesian Y component of the impulsive DeltaV (dimension: SmallDistance/Time)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_y_metadata)

    _set_y_metadata = { "offset" : _set_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y.setter
    def y(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_y_metadata, value)

    _get_z_metadata = { "offset" : _get_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def z(self) -> float:
        """Get or set the Cartesian Z component of the impulsive DeltaV (dimension: SmallDistance/Time)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_z_metadata)

    _set_z_metadata = { "offset" : _set_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @z.setter
    def z(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_z_metadata, value)

    _get_azimuth_metadata = { "offset" : _get_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def azimuth(self) -> typing.Any:
        """Get or set the spherical Azimuth angle of the impulsive DeltaV (dimension: Angle)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_azimuth_metadata)

    _set_azimuth_metadata = { "offset" : _set_azimuth_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @azimuth.setter
    def azimuth(self, value:typing.Any) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_azimuth_metadata, value)

    _get_elevation_metadata = { "offset" : _get_elevation_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def elevation(self) -> typing.Any:
        """Get or set the spherical Elevation angle of the impulsive DeltaV (dimension: Angle)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_elevation_metadata)

    _set_elevation_metadata = { "offset" : _set_elevation_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @elevation.setter
    def elevation(self, value:typing.Any) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_elevation_metadata, value)

    _get_magnitude_metadata = { "offset" : _get_magnitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def magnitude(self) -> float:
        """Get or set the spherical Magnitude of the impulsive DeltaV (dimension: SmallDistance/Time)."""
        return self._intf.get_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._get_magnitude_metadata)

    _set_magnitude_metadata = { "offset" : _set_magnitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @magnitude.setter
    def magnitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._set_magnitude_metadata, value)

    _assign_cartesian_metadata = { "offset" : _assign_cartesian_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def assign_cartesian(self, x_value:float, y_value:float, z_value:float) -> None:
        """Assign all three Cartesian components of the DeltaV vector (dimension: SmallDistance/Time)."""
        return self._intf.invoke(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._assign_cartesian_metadata, x_value, y_value, z_value)

    _query_cartesian_metadata = { "offset" : _query_cartesian_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def query_cartesian(self) -> list:
        """Get all three Cartesian components of the DeltaV vector as an array (dimension: SmallDistance/Time)."""
        return self._intf.invoke(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._query_cartesian_metadata, OutArg())

    _assign_spherical_metadata = { "offset" : _assign_spherical_method_offset,
            "arg_types" : (agcom.Variant, agcom.Variant, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantArg, agmarshall.DoubleArg,) }
    def assign_spherical(self, azimuth_value:typing.Any, elevation_value:typing.Any, magnitude_value:float) -> None:
        """Assign all three spherical components of the DeltaV vector (order Az, El, Mag; dimensions: Angle, Angle, SmallDistance/Time)."""
        return self._intf.invoke(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._assign_spherical_metadata, azimuth_value, elevation_value, magnitude_value)

    _query_spherical_metadata = { "offset" : _query_spherical_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def query_spherical(self) -> list:
        """Get all three spherical components of the DeltaV vector as an array (order Az, El, Mag; dimensions: Angle, Angle, SmallDistance/Time)."""
        return self._intf.invoke(AttitudeControlImpulsiveThrustVector._metadata, AttitudeControlImpulsiveThrustVector._query_spherical_metadata, OutArg())

    _property_names[thrust_axes_name] = "thrust_axes_name"
    _property_names[body_constraint_vector] = "body_constraint_vector"
    _property_names[allow_negative_spherical_magnitude] = "allow_negative_spherical_magnitude"
    _property_names[coord_type] = "coord_type"
    _property_names[x] = "x"
    _property_names[y] = "y"
    _property_names[z] = "z"
    _property_names[azimuth] = "azimuth"
    _property_names[elevation] = "elevation"
    _property_names[magnitude] = "magnitude"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlImpulsiveThrustVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlImpulsiveThrustVector)
        IAttitudeControlImpulsive.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlImpulsive._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlImpulsiveThrustVector, [AttitudeControlImpulsiveThrustVector, IAttitudeControlImpulsive, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5575491667768589580, 12658580146838550400), AttitudeControlImpulsiveThrustVector)
agcls.AgTypeNameMap["AttitudeControlImpulsiveThrustVector"] = AttitudeControlImpulsiveThrustVector

class AttitudeControlFiniteAntiVelocityVector(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Anti-Velocity Vector attitude control for a Finite Maneuver."""

    _num_methods = 3
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_attitude_update_method_offset = 1
    _set_attitude_update_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _metadata = {
        "iid_data" : (4782013786436564730, 1569290256608416660),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteAntiVelocityVector)

    _get_attitude_update_metadata = { "offset" : _get_attitude_update_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @property
    def attitude_update(self) -> "AttitudeUpdate":
        """How and when the attitude will be updated."""
        return self._intf.get_property(AttitudeControlFiniteAntiVelocityVector._metadata, AttitudeControlFiniteAntiVelocityVector._get_attitude_update_metadata)

    _set_attitude_update_metadata = { "offset" : _set_attitude_update_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @attitude_update.setter
    def attitude_update(self, value:"AttitudeUpdate") -> None:
        return self._intf.set_property(AttitudeControlFiniteAntiVelocityVector._metadata, AttitudeControlFiniteAntiVelocityVector._set_attitude_update_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlFiniteAntiVelocityVector._metadata, AttitudeControlFiniteAntiVelocityVector._get_body_constraint_vector_metadata)

    _property_names[attitude_update] = "attitude_update"
    _property_names[body_constraint_vector] = "body_constraint_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteAntiVelocityVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteAntiVelocityVector)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteAntiVelocityVector, [AttitudeControlFiniteAntiVelocityVector, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4929934656189608976, 9775493696746436502), AttitudeControlFiniteAntiVelocityVector)
agcls.AgTypeNameMap["AttitudeControlFiniteAntiVelocityVector"] = AttitudeControlFiniteAntiVelocityVector

class AttitudeControlFiniteAttitude(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Attitude attitude control for a Finite Maneuver."""

    _num_methods = 5
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_attitude_update_method_offset = 1
    _set_attitude_update_method_offset = 2
    _get_reference_axes_name_method_offset = 3
    _set_reference_axes_name_method_offset = 4
    _get_orientation_method_offset = 5
    _metadata = {
        "iid_data" : (4631154172073222433, 9787163487429423038),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteAttitude)

    _get_attitude_update_metadata = { "offset" : _get_attitude_update_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @property
    def attitude_update(self) -> "AttitudeUpdate":
        """How and when the attitude will be updated."""
        return self._intf.get_property(AttitudeControlFiniteAttitude._metadata, AttitudeControlFiniteAttitude._get_attitude_update_metadata)

    _set_attitude_update_metadata = { "offset" : _set_attitude_update_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @attitude_update.setter
    def attitude_update(self, value:"AttitudeUpdate") -> None:
        return self._intf.set_property(AttitudeControlFiniteAttitude._metadata, AttitudeControlFiniteAttitude._set_attitude_update_metadata, value)

    _get_reference_axes_name_metadata = { "offset" : _get_reference_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_axes_name(self) -> str:
        """Ref Axes - the reference axes to be used in modeling this maneuver."""
        return self._intf.get_property(AttitudeControlFiniteAttitude._metadata, AttitudeControlFiniteAttitude._get_reference_axes_name_metadata)

    _set_reference_axes_name_metadata = { "offset" : _set_reference_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_axes_name.setter
    def reference_axes_name(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlFiniteAttitude._metadata, AttitudeControlFiniteAttitude._set_reference_axes_name_metadata, value)

    _get_orientation_metadata = { "offset" : _get_orientation_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def orientation(self) -> "IOrientation":
        """Get the orientation of the attitude."""
        return self._intf.get_property(AttitudeControlFiniteAttitude._metadata, AttitudeControlFiniteAttitude._get_orientation_metadata)

    _property_names[attitude_update] = "attitude_update"
    _property_names[reference_axes_name] = "reference_axes_name"
    _property_names[orientation] = "orientation"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteAttitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteAttitude)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteAttitude, [AttitudeControlFiniteAttitude, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5543774537829345684, 6248581389650464156), AttitudeControlFiniteAttitude)
agcls.AgTypeNameMap["AttitudeControlFiniteAttitude"] = AttitudeControlFiniteAttitude

class AttitudeControlFiniteFile(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the File attitude control for a Finite Maneuver."""

    _num_methods = 5
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_filename_method_offset = 1
    _set_filename_method_offset = 2
    _get_file_time_offset_method_offset = 3
    _set_file_time_offset_method_offset = 4
    _get_full_filename_method_offset = 5
    _metadata = {
        "iid_data" : (5395533152266767476, 10947136709492955554),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteFile)

    _get_filename_metadata = { "offset" : _get_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filename(self) -> str:
        """Get or set the attitude file to use."""
        return self._intf.get_property(AttitudeControlFiniteFile._metadata, AttitudeControlFiniteFile._get_filename_metadata)

    _set_filename_metadata = { "offset" : _set_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @filename.setter
    def filename(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlFiniteFile._metadata, AttitudeControlFiniteFile._set_filename_metadata, value)

    _get_file_time_offset_metadata = { "offset" : _get_file_time_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def file_time_offset(self) -> float:
        """Get or set the time offset can be used to adjust the time stored in the attitude file. Dimensionless."""
        return self._intf.get_property(AttitudeControlFiniteFile._metadata, AttitudeControlFiniteFile._get_file_time_offset_metadata)

    _set_file_time_offset_metadata = { "offset" : _set_file_time_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @file_time_offset.setter
    def file_time_offset(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteFile._metadata, AttitudeControlFiniteFile._set_file_time_offset_metadata, value)

    _get_full_filename_metadata = { "offset" : _get_full_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def full_filename(self) -> str:
        """Get the full path and name of the attitude file to use."""
        return self._intf.get_property(AttitudeControlFiniteFile._metadata, AttitudeControlFiniteFile._get_full_filename_metadata)

    _property_names[filename] = "filename"
    _property_names[file_time_offset] = "file_time_offset"
    _property_names[full_filename] = "full_filename"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteFile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteFile)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteFile, [AttitudeControlFiniteFile, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5304200409859175388, 7105606624544560287), AttitudeControlFiniteFile)
agcls.AgTypeNameMap["AttitudeControlFiniteFile"] = AttitudeControlFiniteFile

class AttitudeControlFiniteThrustVector(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Thrust Vector attitude control for a Finite Maneuver."""

    _num_methods = 6
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_attitude_update_method_offset = 1
    _set_attitude_update_method_offset = 2
    _get_thrust_axes_name_method_offset = 3
    _set_thrust_axes_name_method_offset = 4
    _get_body_constraint_vector_method_offset = 5
    _get_thrust_vector_method_offset = 6
    _metadata = {
        "iid_data" : (5148522151278071898, 11453760759581062313),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteThrustVector)

    _get_attitude_update_metadata = { "offset" : _get_attitude_update_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @property
    def attitude_update(self) -> "AttitudeUpdate":
        """How and when the attitude will be updated."""
        return self._intf.get_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._get_attitude_update_metadata)

    _set_attitude_update_metadata = { "offset" : _set_attitude_update_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @attitude_update.setter
    def attitude_update(self, value:"AttitudeUpdate") -> None:
        return self._intf.set_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._set_attitude_update_metadata, value)

    _get_thrust_axes_name_metadata = { "offset" : _get_thrust_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def thrust_axes_name(self) -> str:
        """Get or set the thrust axes."""
        return self._intf.get_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._get_thrust_axes_name_metadata)

    _set_thrust_axes_name_metadata = { "offset" : _set_thrust_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @thrust_axes_name.setter
    def thrust_axes_name(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._set_thrust_axes_name_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._get_body_constraint_vector_metadata)

    _get_thrust_vector_metadata = { "offset" : _get_thrust_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def thrust_vector(self) -> "IDirection":
        """Define the thrust vector in the reference axes."""
        return self._intf.get_property(AttitudeControlFiniteThrustVector._metadata, AttitudeControlFiniteThrustVector._get_thrust_vector_metadata)

    _property_names[attitude_update] = "attitude_update"
    _property_names[thrust_axes_name] = "thrust_axes_name"
    _property_names[body_constraint_vector] = "body_constraint_vector"
    _property_names[thrust_vector] = "thrust_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteThrustVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteThrustVector)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteThrustVector, [AttitudeControlFiniteThrustVector, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5300112662321021295, 17392290777368689581), AttitudeControlFiniteThrustVector)
agcls.AgTypeNameMap["AttitudeControlFiniteThrustVector"] = AttitudeControlFiniteThrustVector

class AttitudeControlFiniteTimeVarying(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Time Varying attitude control for a Finite Maneuver."""

    _num_methods = 35
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_thrust_axes_name_method_offset = 1
    _set_thrust_axes_name_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _get_azimuth_polynomial_constant_term_method_offset = 4
    _set_azimuth_polynomial_constant_term_method_offset = 5
    _get_azimuth_polynomial_linear_term_method_offset = 6
    _set_azimuth_polynomial_linear_term_method_offset = 7
    _get_azimuth_polynomial_quadratic_term_method_offset = 8
    _set_azimuth_polynomial_quadratic_term_method_offset = 9
    _get_azimuth_polynomial_cubic_term_method_offset = 10
    _set_azimuth_polynomial_cubic_term_method_offset = 11
    _get_azimuth_polynomial_quartic_term_method_offset = 12
    _set_azimuth_polynomial_quartic_term_method_offset = 13
    _get_azimuth_sinusoidal_amplitude_method_offset = 14
    _set_azimuth_sinusoidal_amplitude_method_offset = 15
    _get_azimuth_sinusoidal_frequency_method_offset = 16
    _set_azimuth_sinusoidal_frequency_method_offset = 17
    _get_azimuth_sinusoidal_phase_method_offset = 18
    _set_azimuth_sinusoidal_phase_method_offset = 19
    _get_elevation_polynomial_constant_term_method_offset = 20
    _set_elevation_polynomial_constant_term_method_offset = 21
    _get_elevation_polynomial_linear_term_method_offset = 22
    _set_elevation_polynomial_linear_term_method_offset = 23
    _get_elevation_polynomial_quadratic_term_method_offset = 24
    _set_elevation_polynomial_quadratic_term_method_offset = 25
    _get_elevation_polynomial_cubic_term_method_offset = 26
    _set_elevation_polynomial_cubic_term_method_offset = 27
    _get_elevation_polynomial_quartic_term_method_offset = 28
    _set_elevation_polynomial_quartic_term_method_offset = 29
    _get_elevation_sinusoidal_amplitude_method_offset = 30
    _set_elevation_sinusoidal_amplitude_method_offset = 31
    _get_elevation_sinusoidal_frequency_method_offset = 32
    _set_elevation_sinusoidal_frequency_method_offset = 33
    _get_elevation_sinusoidal_phase_method_offset = 34
    _set_elevation_sinusoidal_phase_method_offset = 35
    _metadata = {
        "iid_data" : (5634020525553782637, 14867654061630199955),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteTimeVarying)

    _get_thrust_axes_name_metadata = { "offset" : _get_thrust_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def thrust_axes_name(self) -> str:
        """Get or set the thrust axes."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_thrust_axes_name_metadata)

    _set_thrust_axes_name_metadata = { "offset" : _set_thrust_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @thrust_axes_name.setter
    def thrust_axes_name(self, value:str) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_thrust_axes_name_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_body_constraint_vector_metadata)

    _get_azimuth_polynomial_constant_term_metadata = { "offset" : _get_azimuth_polynomial_constant_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_polynomial_constant_term(self) -> float:
        """Azimuth constant term (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_polynomial_constant_term_metadata)

    _set_azimuth_polynomial_constant_term_metadata = { "offset" : _set_azimuth_polynomial_constant_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_polynomial_constant_term.setter
    def azimuth_polynomial_constant_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_polynomial_constant_term_metadata, value)

    _get_azimuth_polynomial_linear_term_metadata = { "offset" : _get_azimuth_polynomial_linear_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_polynomial_linear_term(self) -> float:
        """Azimuth linear term (dimension: angle/time)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_polynomial_linear_term_metadata)

    _set_azimuth_polynomial_linear_term_metadata = { "offset" : _set_azimuth_polynomial_linear_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_polynomial_linear_term.setter
    def azimuth_polynomial_linear_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_polynomial_linear_term_metadata, value)

    _get_azimuth_polynomial_quadratic_term_metadata = { "offset" : _get_azimuth_polynomial_quadratic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_polynomial_quadratic_term(self) -> float:
        """Azimuth quadratic term (dimension: angle/time^2)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_polynomial_quadratic_term_metadata)

    _set_azimuth_polynomial_quadratic_term_metadata = { "offset" : _set_azimuth_polynomial_quadratic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_polynomial_quadratic_term.setter
    def azimuth_polynomial_quadratic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_polynomial_quadratic_term_metadata, value)

    _get_azimuth_polynomial_cubic_term_metadata = { "offset" : _get_azimuth_polynomial_cubic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_polynomial_cubic_term(self) -> float:
        """Azimuth cubic term (dimension: angle/time^3)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_polynomial_cubic_term_metadata)

    _set_azimuth_polynomial_cubic_term_metadata = { "offset" : _set_azimuth_polynomial_cubic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_polynomial_cubic_term.setter
    def azimuth_polynomial_cubic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_polynomial_cubic_term_metadata, value)

    _get_azimuth_polynomial_quartic_term_metadata = { "offset" : _get_azimuth_polynomial_quartic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_polynomial_quartic_term(self) -> float:
        """Azimuth quartic term (dimension: angle/time^4)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_polynomial_quartic_term_metadata)

    _set_azimuth_polynomial_quartic_term_metadata = { "offset" : _set_azimuth_polynomial_quartic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_polynomial_quartic_term.setter
    def azimuth_polynomial_quartic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_polynomial_quartic_term_metadata, value)

    _get_azimuth_sinusoidal_amplitude_metadata = { "offset" : _get_azimuth_sinusoidal_amplitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_sinusoidal_amplitude(self) -> float:
        """Azimuth sine term amplitude (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_sinusoidal_amplitude_metadata)

    _set_azimuth_sinusoidal_amplitude_metadata = { "offset" : _set_azimuth_sinusoidal_amplitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_sinusoidal_amplitude.setter
    def azimuth_sinusoidal_amplitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_sinusoidal_amplitude_metadata, value)

    _get_azimuth_sinusoidal_frequency_metadata = { "offset" : _get_azimuth_sinusoidal_frequency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_sinusoidal_frequency(self) -> float:
        """Azimuth sine term frequency (dimension: angle/time)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_sinusoidal_frequency_metadata)

    _set_azimuth_sinusoidal_frequency_metadata = { "offset" : _set_azimuth_sinusoidal_frequency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_sinusoidal_frequency.setter
    def azimuth_sinusoidal_frequency(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_sinusoidal_frequency_metadata, value)

    _get_azimuth_sinusoidal_phase_metadata = { "offset" : _get_azimuth_sinusoidal_phase_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth_sinusoidal_phase(self) -> float:
        """Azimuth sine term phase (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_azimuth_sinusoidal_phase_metadata)

    _set_azimuth_sinusoidal_phase_metadata = { "offset" : _set_azimuth_sinusoidal_phase_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @azimuth_sinusoidal_phase.setter
    def azimuth_sinusoidal_phase(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_azimuth_sinusoidal_phase_metadata, value)

    _get_elevation_polynomial_constant_term_metadata = { "offset" : _get_elevation_polynomial_constant_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_polynomial_constant_term(self) -> float:
        """Elevation constant term (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_polynomial_constant_term_metadata)

    _set_elevation_polynomial_constant_term_metadata = { "offset" : _set_elevation_polynomial_constant_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_polynomial_constant_term.setter
    def elevation_polynomial_constant_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_polynomial_constant_term_metadata, value)

    _get_elevation_polynomial_linear_term_metadata = { "offset" : _get_elevation_polynomial_linear_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_polynomial_linear_term(self) -> float:
        """Elevation linear term (dimension: angle/time)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_polynomial_linear_term_metadata)

    _set_elevation_polynomial_linear_term_metadata = { "offset" : _set_elevation_polynomial_linear_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_polynomial_linear_term.setter
    def elevation_polynomial_linear_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_polynomial_linear_term_metadata, value)

    _get_elevation_polynomial_quadratic_term_metadata = { "offset" : _get_elevation_polynomial_quadratic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_polynomial_quadratic_term(self) -> float:
        """Elevation quadratic term (dimension: angle/time^2)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_polynomial_quadratic_term_metadata)

    _set_elevation_polynomial_quadratic_term_metadata = { "offset" : _set_elevation_polynomial_quadratic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_polynomial_quadratic_term.setter
    def elevation_polynomial_quadratic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_polynomial_quadratic_term_metadata, value)

    _get_elevation_polynomial_cubic_term_metadata = { "offset" : _get_elevation_polynomial_cubic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_polynomial_cubic_term(self) -> float:
        """Elevation cubic term (dimension: angle/time^3)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_polynomial_cubic_term_metadata)

    _set_elevation_polynomial_cubic_term_metadata = { "offset" : _set_elevation_polynomial_cubic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_polynomial_cubic_term.setter
    def elevation_polynomial_cubic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_polynomial_cubic_term_metadata, value)

    _get_elevation_polynomial_quartic_term_metadata = { "offset" : _get_elevation_polynomial_quartic_term_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_polynomial_quartic_term(self) -> float:
        """Elevation quartic term (dimension: angle/time^4)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_polynomial_quartic_term_metadata)

    _set_elevation_polynomial_quartic_term_metadata = { "offset" : _set_elevation_polynomial_quartic_term_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_polynomial_quartic_term.setter
    def elevation_polynomial_quartic_term(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_polynomial_quartic_term_metadata, value)

    _get_elevation_sinusoidal_amplitude_metadata = { "offset" : _get_elevation_sinusoidal_amplitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_sinusoidal_amplitude(self) -> float:
        """Elevation sine term amplitude (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_sinusoidal_amplitude_metadata)

    _set_elevation_sinusoidal_amplitude_metadata = { "offset" : _set_elevation_sinusoidal_amplitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_sinusoidal_amplitude.setter
    def elevation_sinusoidal_amplitude(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_sinusoidal_amplitude_metadata, value)

    _get_elevation_sinusoidal_frequency_metadata = { "offset" : _get_elevation_sinusoidal_frequency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_sinusoidal_frequency(self) -> float:
        """Elevation sine term frequency (dimension: angle/time)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_sinusoidal_frequency_metadata)

    _set_elevation_sinusoidal_frequency_metadata = { "offset" : _set_elevation_sinusoidal_frequency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_sinusoidal_frequency.setter
    def elevation_sinusoidal_frequency(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_sinusoidal_frequency_metadata, value)

    _get_elevation_sinusoidal_phase_metadata = { "offset" : _get_elevation_sinusoidal_phase_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation_sinusoidal_phase(self) -> float:
        """Elevation sine term phase (dimension: angle)."""
        return self._intf.get_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._get_elevation_sinusoidal_phase_metadata)

    _set_elevation_sinusoidal_phase_metadata = { "offset" : _set_elevation_sinusoidal_phase_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @elevation_sinusoidal_phase.setter
    def elevation_sinusoidal_phase(self, value:float) -> None:
        return self._intf.set_property(AttitudeControlFiniteTimeVarying._metadata, AttitudeControlFiniteTimeVarying._set_elevation_sinusoidal_phase_metadata, value)

    _property_names[thrust_axes_name] = "thrust_axes_name"
    _property_names[body_constraint_vector] = "body_constraint_vector"
    _property_names[azimuth_polynomial_constant_term] = "azimuth_polynomial_constant_term"
    _property_names[azimuth_polynomial_linear_term] = "azimuth_polynomial_linear_term"
    _property_names[azimuth_polynomial_quadratic_term] = "azimuth_polynomial_quadratic_term"
    _property_names[azimuth_polynomial_cubic_term] = "azimuth_polynomial_cubic_term"
    _property_names[azimuth_polynomial_quartic_term] = "azimuth_polynomial_quartic_term"
    _property_names[azimuth_sinusoidal_amplitude] = "azimuth_sinusoidal_amplitude"
    _property_names[azimuth_sinusoidal_frequency] = "azimuth_sinusoidal_frequency"
    _property_names[azimuth_sinusoidal_phase] = "azimuth_sinusoidal_phase"
    _property_names[elevation_polynomial_constant_term] = "elevation_polynomial_constant_term"
    _property_names[elevation_polynomial_linear_term] = "elevation_polynomial_linear_term"
    _property_names[elevation_polynomial_quadratic_term] = "elevation_polynomial_quadratic_term"
    _property_names[elevation_polynomial_cubic_term] = "elevation_polynomial_cubic_term"
    _property_names[elevation_polynomial_quartic_term] = "elevation_polynomial_quartic_term"
    _property_names[elevation_sinusoidal_amplitude] = "elevation_sinusoidal_amplitude"
    _property_names[elevation_sinusoidal_frequency] = "elevation_sinusoidal_frequency"
    _property_names[elevation_sinusoidal_phase] = "elevation_sinusoidal_phase"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteTimeVarying."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteTimeVarying)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteTimeVarying, [AttitudeControlFiniteTimeVarying, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4702333051035569318, 8055730207611007421), AttitudeControlFiniteTimeVarying)
agcls.AgTypeNameMap["AttitudeControlFiniteTimeVarying"] = AttitudeControlFiniteTimeVarying

class AttitudeControlFiniteVelocityVector(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Velocity Vector attitude control for a Finite Maneuver."""

    _num_methods = 3
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _get_attitude_update_method_offset = 1
    _set_attitude_update_method_offset = 2
    _get_body_constraint_vector_method_offset = 3
    _metadata = {
        "iid_data" : (5137071414965646431, 4057671418243972257),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFiniteVelocityVector)

    _get_attitude_update_metadata = { "offset" : _get_attitude_update_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @property
    def attitude_update(self) -> "AttitudeUpdate":
        """How and when the attitude will be updated."""
        return self._intf.get_property(AttitudeControlFiniteVelocityVector._metadata, AttitudeControlFiniteVelocityVector._get_attitude_update_metadata)

    _set_attitude_update_metadata = { "offset" : _set_attitude_update_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AttitudeUpdate),) }
    @attitude_update.setter
    def attitude_update(self, value:"AttitudeUpdate") -> None:
        return self._intf.set_property(AttitudeControlFiniteVelocityVector._metadata, AttitudeControlFiniteVelocityVector._set_attitude_update_metadata, value)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlFiniteVelocityVector._metadata, AttitudeControlFiniteVelocityVector._get_body_constraint_vector_metadata)

    _property_names[attitude_update] = "attitude_update"
    _property_names[body_constraint_vector] = "body_constraint_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFiniteVelocityVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFiniteVelocityVector)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFiniteVelocityVector, [AttitudeControlFiniteVelocityVector, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5340603337482853225, 4608082530829545350), AttitudeControlFiniteVelocityVector)
agcls.AgTypeNameMap["AttitudeControlFiniteVelocityVector"] = AttitudeControlFiniteVelocityVector

class AttitudeControlFinitePlugin(IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Plugin attitude control for a Finite Maneuver."""

    _num_methods = 3
    _vtable_offset = IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods
    _select_plugin_by_name_method_offset = 1
    _get_plugin_name_method_offset = 2
    _get_plugin_config_method_offset = 3
    _metadata = {
        "iid_data" : (4773268931231490560, 6457243350605167235),
        "vtable_reference" : IAttitudeControlFinite._vtable_offset + IAttitudeControlFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlFinitePlugin)

    _select_plugin_by_name_metadata = { "offset" : _select_plugin_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def select_plugin_by_name(self, name:str) -> None:
        """Select plugin using the plugin name."""
        return self._intf.invoke(AttitudeControlFinitePlugin._metadata, AttitudeControlFinitePlugin._select_plugin_by_name_metadata, name)

    _get_plugin_name_metadata = { "offset" : _get_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_name(self) -> str:
        """Get the selected plugin's name."""
        return self._intf.get_property(AttitudeControlFinitePlugin._metadata, AttitudeControlFinitePlugin._get_plugin_name_metadata)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(AttitudeControlFinitePlugin._metadata, AttitudeControlFinitePlugin._get_plugin_config_metadata)

    _property_names[plugin_name] = "plugin_name"
    _property_names[plugin_config] = "plugin_config"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlFinitePlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlFinitePlugin)
        IAttitudeControlFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlFinitePlugin, [AttitudeControlFinitePlugin, IAttitudeControlFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5751876833050268726, 10430523435175771071), AttitudeControlFinitePlugin)
agcls.AgTypeNameMap["AttitudeControlFinitePlugin"] = AttitudeControlFinitePlugin

class AttitudeControlOptimalFiniteLagrange(IAttitudeControlOptimalFinite, IAttitudeControl, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Lagrange Interpolation attitude control for a Optimal Finite Maneuver."""

    _num_methods = 1
    _vtable_offset = IAttitudeControlOptimalFinite._vtable_offset + IAttitudeControlOptimalFinite._num_methods
    _get_body_constraint_vector_method_offset = 1
    _metadata = {
        "iid_data" : (5193424269214069960, 1358925997096785086),
        "vtable_reference" : IAttitudeControlOptimalFinite._vtable_offset + IAttitudeControlOptimalFinite._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeControlOptimalFiniteLagrange)

    _get_body_constraint_vector_metadata = { "offset" : _get_body_constraint_vector_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def body_constraint_vector(self) -> "IDirection":
        """Define a constraint vector in spacecraft body coordinates to complete the attitude definition."""
        return self._intf.get_property(AttitudeControlOptimalFiniteLagrange._metadata, AttitudeControlOptimalFiniteLagrange._get_body_constraint_vector_metadata)

    _property_names[body_constraint_vector] = "body_constraint_vector"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeControlOptimalFiniteLagrange."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeControlOptimalFiniteLagrange)
        IAttitudeControlOptimalFinite.__init__(self, source_object)
        IAttitudeControl.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IAttitudeControlOptimalFinite._private_init(self, intf)
        IAttitudeControl._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AttitudeControlOptimalFiniteLagrange, [AttitudeControlOptimalFiniteLagrange, IAttitudeControlOptimalFinite, IAttitudeControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4745590117958740244, 14748864079568769432), AttitudeControlOptimalFiniteLagrange)
agcls.AgTypeNameMap["AttitudeControlOptimalFiniteLagrange"] = AttitudeControlOptimalFiniteLagrange

class ManeuverFinitePropagator(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the propagation of a Finite Maneuver."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propagator_name_method_offset = 1
    _set_propagator_name_method_offset = 2
    _get_stopping_conditions_method_offset = 3
    _get_min_propagation_time_method_offset = 4
    _set_min_propagation_time_method_offset = 5
    _get_max_propagation_time_method_offset = 6
    _set_max_propagation_time_method_offset = 7
    _get_enable_max_propagation_time_method_offset = 8
    _set_enable_max_propagation_time_method_offset = 9
    _get_enable_warning_message_method_offset = 10
    _set_enable_warning_message_method_offset = 11
    _get_enable_center_burn_method_offset = 12
    _set_enable_center_burn_method_offset = 13
    _get_bias_method_offset = 14
    _set_bias_method_offset = 15
    _get_override_max_propagation_time_method_offset = 16
    _set_override_max_propagation_time_method_offset = 17
    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 18
    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 19
    _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 20
    _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 21
    _metadata = {
        "iid_data" : (5566679304303890544, 11813338934988407462),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverFinitePropagator)

    _get_propagator_name_metadata = { "offset" : _get_propagator_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propagator_name(self) -> str:
        """Get or set the propagator."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_propagator_name_metadata)

    _set_propagator_name_metadata = { "offset" : _set_propagator_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @propagator_name.setter
    def propagator_name(self, value:str) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_propagator_name_metadata, value)

    _get_stopping_conditions_metadata = { "offset" : _get_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def stopping_conditions(self) -> "StoppingConditionCollection":
        """Get the stopping conditions list."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_stopping_conditions_metadata)

    _get_min_propagation_time_metadata = { "offset" : _get_min_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_propagation_time(self) -> float:
        """Minimum Propagation Time - the minimum time that must elapse from the beginning of the segment until Astrogator will begin checking stopping conditions for satisfaction. Uses Time Dimension."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_min_propagation_time_metadata)

    _set_min_propagation_time_metadata = { "offset" : _set_min_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_propagation_time.setter
    def min_propagation_time(self, value:float) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_min_propagation_time_metadata, value)

    _get_max_propagation_time_metadata = { "offset" : _get_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_propagation_time(self) -> float:
        """Maximum Propagation Time - the maximum propagation time, after which the segment will end regardless of whether the stopping conditions have been satisfied. Uses Time Dimension."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_max_propagation_time_metadata)

    _set_max_propagation_time_metadata = { "offset" : _set_max_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_propagation_time.setter
    def max_propagation_time(self, value:float) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_max_propagation_time_metadata, value)

    _get_enable_max_propagation_time_metadata = { "offset" : _get_enable_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_max_propagation_time(self) -> bool:
        """Enable Maximum Propagation Time - apply the maximum propagation time."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_enable_max_propagation_time_metadata)

    _set_enable_max_propagation_time_metadata = { "offset" : _set_enable_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_max_propagation_time.setter
    def enable_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_enable_max_propagation_time_metadata, value)

    _get_enable_warning_message_metadata = { "offset" : _get_enable_warning_message_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_warning_message(self) -> bool:
        """Issue a warning message if propagation is stopped by the Maximum Propagation Time parameter."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_enable_warning_message_metadata)

    _set_enable_warning_message_metadata = { "offset" : _set_enable_warning_message_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_warning_message.setter
    def enable_warning_message(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_enable_warning_message_metadata, value)

    _get_enable_center_burn_metadata = { "offset" : _get_enable_center_burn_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_center_burn(self) -> bool:
        """Get or set the option to start the maneuver half the time before the previous segment ended. This property is only available for use with a duration stopping condition."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_enable_center_burn_metadata)

    _set_enable_center_burn_metadata = { "offset" : _set_enable_center_burn_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_center_burn.setter
    def enable_center_burn(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_enable_center_burn_metadata, value)

    _get_bias_metadata = { "offset" : _get_bias_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bias(self) -> float:
        """Get or set the value by which to adjust the centering of the burn. A positive value will center the burn after the previous segment ends by the amount specified in the Burn Center Bias field. Uses Time Dimension."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_bias_metadata)

    _set_bias_metadata = { "offset" : _set_bias_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @bias.setter
    def bias(self, value:float) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_bias_metadata, value)

    _get_override_max_propagation_time_metadata = { "offset" : _get_override_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def override_max_propagation_time(self) -> bool:
        """Override Maximum Propagation Time - if there is a duration or epoch stopping condition that occurs after the maximum propagation time, ignore the maximum propagation time."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_override_max_propagation_time_metadata)

    _set_override_max_propagation_time_metadata = { "offset" : _set_override_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @override_max_propagation_time.setter
    def override_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_override_max_propagation_time_metadata, value)

    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self) -> bool:
        """Stop immediately if propagation begins beyond an active epoch stopping condition."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata)

    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_stop_for_initially_surpassed_epoch_stopping_conditions.setter
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata, value)

    _get_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_reinitialize_stm_at_start_of_segment_propagation(self) -> bool:
        """If this segment is propagating the state transition matrix, reset it to the identity matrix at the start of the segment."""
        return self._intf.get_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._get_should_reinitialize_stm_at_start_of_segment_propagation_metadata)

    _set_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_reinitialize_stm_at_start_of_segment_propagation.setter
    def should_reinitialize_stm_at_start_of_segment_propagation(self, value:bool) -> None:
        return self._intf.set_property(ManeuverFinitePropagator._metadata, ManeuverFinitePropagator._set_should_reinitialize_stm_at_start_of_segment_propagation_metadata, value)

    _property_names[propagator_name] = "propagator_name"
    _property_names[stopping_conditions] = "stopping_conditions"
    _property_names[min_propagation_time] = "min_propagation_time"
    _property_names[max_propagation_time] = "max_propagation_time"
    _property_names[enable_max_propagation_time] = "enable_max_propagation_time"
    _property_names[enable_warning_message] = "enable_warning_message"
    _property_names[enable_center_burn] = "enable_center_burn"
    _property_names[bias] = "bias"
    _property_names[override_max_propagation_time] = "override_max_propagation_time"
    _property_names[should_stop_for_initially_surpassed_epoch_stopping_conditions] = "should_stop_for_initially_surpassed_epoch_stopping_conditions"
    _property_names[should_reinitialize_stm_at_start_of_segment_propagation] = "should_reinitialize_stm_at_start_of_segment_propagation"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverFinitePropagator."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverFinitePropagator)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverFinitePropagator, [ManeuverFinitePropagator, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5539664440505171113, 10732172948923783042), ManeuverFinitePropagator)
agcls.AgTypeNameMap["ManeuverFinitePropagator"] = ManeuverFinitePropagator

class MCSHold(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Hold segment."""

    _num_methods = 23
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_step_size_method_offset = 1
    _set_step_size_method_offset = 2
    _get_hold_frame_name_method_offset = 3
    _set_hold_frame_name_method_offset = 4
    _get_enable_hold_attitude_method_offset = 5
    _set_enable_hold_attitude_method_offset = 6
    _get_stopping_conditions_method_offset = 7
    _get_min_propagation_time_method_offset = 8
    _set_min_propagation_time_method_offset = 9
    _get_max_propagation_time_method_offset = 10
    _set_max_propagation_time_method_offset = 11
    _get_enable_max_propagation_time_method_offset = 12
    _set_enable_max_propagation_time_method_offset = 13
    _get_enable_warning_message_method_offset = 14
    _set_enable_warning_message_method_offset = 15
    _enable_control_parameter_method_offset = 16
    _disable_control_parameter_method_offset = 17
    _is_control_parameter_enabled_method_offset = 18
    _get_control_parameters_available_method_offset = 19
    _get_override_max_propagation_time_method_offset = 20
    _set_override_max_propagation_time_method_offset = 21
    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 22
    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset = 23
    _metadata = {
        "iid_data" : (4662680246288167963, 8721114741357391511),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSHold)

    _get_step_size_metadata = { "offset" : _get_step_size_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def step_size(self) -> float:
        """Get or set the time interval between calculated ephemeris output points. Uses Time Dimension."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_step_size_metadata)

    _set_step_size_metadata = { "offset" : _set_step_size_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @step_size.setter
    def step_size(self, value:float) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_step_size_metadata, value)

    _get_hold_frame_name_metadata = { "offset" : _get_hold_frame_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def hold_frame_name(self) -> str:
        """Hold Frame - the reference frame of the Hold segment."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_hold_frame_name_metadata)

    _set_hold_frame_name_metadata = { "offset" : _set_hold_frame_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @hold_frame_name.setter
    def hold_frame_name(self, value:str) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_hold_frame_name_metadata, value)

    _get_enable_hold_attitude_metadata = { "offset" : _get_enable_hold_attitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_hold_attitude(self) -> bool:
        """Enable Hold Altitude - if true, the spacecraft's attitude is fixed within the hold frame."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_enable_hold_attitude_metadata)

    _set_enable_hold_attitude_metadata = { "offset" : _set_enable_hold_attitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_hold_attitude.setter
    def enable_hold_attitude(self, value:bool) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_enable_hold_attitude_metadata, value)

    _get_stopping_conditions_metadata = { "offset" : _get_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def stopping_conditions(self) -> "StoppingConditionCollection":
        """Get the stopping conditions defined for the segment."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_stopping_conditions_metadata)

    _get_min_propagation_time_metadata = { "offset" : _get_min_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_propagation_time(self) -> float:
        """Minimum Propagation Time - the minimum time that must elapse from the beginning of the segment until Astrogator will begin checking stopping conditions for satisfaction. Uses Time Dimension."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_min_propagation_time_metadata)

    _set_min_propagation_time_metadata = { "offset" : _set_min_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_propagation_time.setter
    def min_propagation_time(self, value:float) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_min_propagation_time_metadata, value)

    _get_max_propagation_time_metadata = { "offset" : _get_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_propagation_time(self) -> float:
        """Maximum Propagation Time - the maximum propagation time, after which the segment will end regardless of whether the stopping conditions have been satisfied. Uses Time Dimension."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_max_propagation_time_metadata)

    _set_max_propagation_time_metadata = { "offset" : _set_max_propagation_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_propagation_time.setter
    def max_propagation_time(self, value:float) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_max_propagation_time_metadata, value)

    _get_enable_max_propagation_time_metadata = { "offset" : _get_enable_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_max_propagation_time(self) -> bool:
        """Enable Maximum Propagation Time - if true, the maximum propagation time will be enforced."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_enable_max_propagation_time_metadata)

    _set_enable_max_propagation_time_metadata = { "offset" : _set_enable_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_max_propagation_time.setter
    def enable_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_enable_max_propagation_time_metadata, value)

    _get_enable_warning_message_metadata = { "offset" : _get_enable_warning_message_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_warning_message(self) -> bool:
        """If true, Astrogator will issue a warning message if propagation is stopped by the Maximum Propagation Time parameter."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_enable_warning_message_metadata)

    _set_enable_warning_message_metadata = { "offset" : _set_enable_warning_message_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_warning_message.setter
    def enable_warning_message(self, value:bool) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_enable_warning_message_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced),) }
    def enable_control_parameter(self, param:"ControlAdvanced") -> None:
        """Enable or disables the specified control parameter."""
        return self._intf.invoke(MCSHold._metadata, MCSHold._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced),) }
    def disable_control_parameter(self, param:"ControlAdvanced") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSHold._metadata, MCSHold._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlAdvanced), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlAdvanced") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSHold._metadata, MCSHold._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_control_parameters_available_metadata)

    _get_override_max_propagation_time_metadata = { "offset" : _get_override_max_propagation_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def override_max_propagation_time(self) -> bool:
        """Override Maximum Propagation Time - if there is a duration or epoch stopping condition that occurs after the maximum propagation time, ignore the maximum propagation time."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_override_max_propagation_time_metadata)

    _set_override_max_propagation_time_metadata = { "offset" : _set_override_max_propagation_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @override_max_propagation_time.setter
    def override_max_propagation_time(self, value:bool) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_override_max_propagation_time_metadata, value)

    _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _get_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self) -> bool:
        """Stop immediately if propagation begins beyond an active epoch stopping condition."""
        return self._intf.get_property(MCSHold._metadata, MCSHold._get_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata)

    _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata = { "offset" : _set_should_stop_for_initially_surpassed_epoch_stopping_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_stop_for_initially_surpassed_epoch_stopping_conditions.setter
    def should_stop_for_initially_surpassed_epoch_stopping_conditions(self, value:bool) -> None:
        return self._intf.set_property(MCSHold._metadata, MCSHold._set_should_stop_for_initially_surpassed_epoch_stopping_conditions_metadata, value)

    _property_names[step_size] = "step_size"
    _property_names[hold_frame_name] = "hold_frame_name"
    _property_names[enable_hold_attitude] = "enable_hold_attitude"
    _property_names[stopping_conditions] = "stopping_conditions"
    _property_names[min_propagation_time] = "min_propagation_time"
    _property_names[max_propagation_time] = "max_propagation_time"
    _property_names[enable_max_propagation_time] = "enable_max_propagation_time"
    _property_names[enable_warning_message] = "enable_warning_message"
    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[override_max_propagation_time] = "override_max_propagation_time"
    _property_names[should_stop_for_initially_surpassed_epoch_stopping_conditions] = "should_stop_for_initially_surpassed_epoch_stopping_conditions"

    def __init__(self, source_object=None):
        """Construct an object of type MCSHold."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSHold)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSHold, [MCSHold, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5036634056898744919, 16511560869260231339), MCSHold)
agcls.AgTypeNameMap["MCSHold"] = MCSHold

class MCSUpdate(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Update segment."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _set_action_and_value_method_offset = 1
    _get_action_method_offset = 2
    _get_value_method_offset = 3
    _set_action_method_offset = 4
    _set_value_method_offset = 5
    _disable_control_parameter_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _is_control_parameter_enabled_method_offset = 8
    _get_control_parameters_available_method_offset = 9
    _get_user_variables_method_offset = 10
    _metadata = {
        "iid_data" : (4612298704220394462, 16427056929712906381),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSUpdate)

    _set_action_and_value_metadata = { "offset" : _set_action_and_value_method_offset,
            "arg_types" : (agcom.LONG, agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(UpdateParam), agmarshall.EnumArg(UpdateAction), agmarshall.DoubleArg,) }
    def set_action_and_value(self, parameter_type:"UpdateParam", action_type:"UpdateAction", value:float) -> None:
        """Set an action and the new value."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._set_action_and_value_metadata, parameter_type, action_type, value)

    _get_action_metadata = { "offset" : _get_action_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(UpdateParam), agmarshall.EnumArg(UpdateAction),) }
    def get_action(self, parameter_type:"UpdateParam") -> "UpdateAction":
        """Get the action type for a parameter."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._get_action_metadata, parameter_type, OutArg())

    _get_value_metadata = { "offset" : _get_value_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.EnumArg(UpdateParam), agmarshall.DoubleArg,) }
    def get_value(self, parameter_type:"UpdateParam") -> float:
        """Get the value type for a parameter."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._get_value_metadata, parameter_type, OutArg())

    _set_action_metadata = { "offset" : _set_action_method_offset,
            "arg_types" : (agcom.LONG, agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(UpdateParam), agmarshall.EnumArg(UpdateAction),) }
    def set_action(self, parameter_name:"UpdateParam", action_type:"UpdateAction") -> None:
        """Set the update action type."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._set_action_metadata, parameter_name, action_type)

    _set_value_metadata = { "offset" : _set_value_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(UpdateParam), agmarshall.DoubleArg,) }
    def set_value(self, parameter_name:"UpdateParam", value:float) -> None:
        """Set the update value."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._set_value_metadata, parameter_name, value)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlUpdate),) }
    def disable_control_parameter(self, param:"ControlUpdate") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._disable_control_parameter_metadata, param)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlUpdate),) }
    def enable_control_parameter(self, param:"ControlUpdate") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._enable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlUpdate), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlUpdate") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(MCSUpdate._metadata, MCSUpdate._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(MCSUpdate._metadata, MCSUpdate._get_control_parameters_available_metadata)

    _get_user_variables_metadata = { "offset" : _get_user_variables_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_variables(self) -> "UserVariableUpdateCollection":
        """Interface used to modify user variables for the update segment."""
        return self._intf.get_property(MCSUpdate._metadata, MCSUpdate._get_user_variables_metadata)

    _property_names[control_parameters_available] = "control_parameters_available"
    _property_names[user_variables] = "user_variables"

    def __init__(self, source_object=None):
        """Construct an object of type MCSUpdate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSUpdate)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSUpdate, [MCSUpdate, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4769851952476936711, 12743095332754810808), MCSUpdate)
agcls.AgTypeNameMap["MCSUpdate"] = MCSUpdate

class MCSReturn(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Return segment."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_return_control_to_parent_sequence_method_offset = 1
    _set_return_control_to_parent_sequence_method_offset = 2
    _metadata = {
        "iid_data" : (5086645245770904087, 7110397434433108120),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSReturn)

    _get_return_control_to_parent_sequence_metadata = { "offset" : _get_return_control_to_parent_sequence_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReturnControl),) }
    @property
    def return_control_to_parent_sequence(self) -> "ReturnControl":
        """Get or set the state of the segment."""
        return self._intf.get_property(MCSReturn._metadata, MCSReturn._get_return_control_to_parent_sequence_metadata)

    _set_return_control_to_parent_sequence_metadata = { "offset" : _set_return_control_to_parent_sequence_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ReturnControl),) }
    @return_control_to_parent_sequence.setter
    def return_control_to_parent_sequence(self, value:"ReturnControl") -> None:
        return self._intf.set_property(MCSReturn._metadata, MCSReturn._set_return_control_to_parent_sequence_metadata, value)

    _property_names[return_control_to_parent_sequence] = "return_control_to_parent_sequence"

    def __init__(self, source_object=None):
        """Construct an object of type MCSReturn."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSReturn)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSReturn, [MCSReturn, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5338959801614235290, 674960884198980233), MCSReturn)
agcls.AgTypeNameMap["MCSReturn"] = MCSReturn

class MCSStop(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Stop segment."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enabled_method_offset = 1
    _set_enabled_method_offset = 2
    _metadata = {
        "iid_data" : (5433661175555402357, 6615063642560173976),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSStop)

    _get_enabled_metadata = { "offset" : _get_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enabled(self) -> bool:
        """If true, the segment will stop the execution of the MCS."""
        return self._intf.get_property(MCSStop._metadata, MCSStop._get_enabled_metadata)

    _set_enabled_metadata = { "offset" : _set_enabled_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enabled.setter
    def enabled(self, value:bool) -> None:
        return self._intf.set_property(MCSStop._metadata, MCSStop._set_enabled_metadata, value)

    _property_names[enabled] = "enabled"

    def __init__(self, source_object=None):
        """Construct an object of type MCSStop."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSStop)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSStop, [MCSStop, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5575190769478601305, 3572350491614611646), MCSStop)
agcls.AgTypeNameMap["MCSStop"] = MCSStop

class MCSTargetSequence(IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable, SupportsDeleteCallback):
    """General properties of a TargetSequence segment."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_action_method_offset = 1
    _set_action_method_offset = 2
    _get_when_profiles_finish_method_offset = 3
    _set_when_profiles_finish_method_offset = 4
    _get_continue_on_failure_method_offset = 5
    _set_continue_on_failure_method_offset = 6
    _get_segments_method_offset = 7
    _get_profiles_method_offset = 8
    _apply_profiles_method_offset = 9
    _reset_profiles_method_offset = 10
    _apply_profile_method_offset = 11
    _reset_profile_method_offset = 12
    _apply_profile_by_name_method_offset = 13
    _reset_profile_by_name_method_offset = 14
    _get_reset_inner_targeters_method_offset = 15
    _set_reset_inner_targeters_method_offset = 16
    _metadata = {
        "iid_data" : (4754863831773773924, 14533412604548864682),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSTargetSequence)

    _get_action_metadata = { "offset" : _get_action_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TargetSequenceAction),) }
    @property
    def action(self) -> "TargetSequenceAction":
        """Whether to run the sequence nominally or using profiles."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_action_metadata)

    _set_action_metadata = { "offset" : _set_action_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TargetSequenceAction),) }
    @action.setter
    def action(self, value:"TargetSequenceAction") -> None:
        return self._intf.set_property(MCSTargetSequence._metadata, MCSTargetSequence._set_action_metadata, value)

    _get_when_profiles_finish_metadata = { "offset" : _get_when_profiles_finish_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ProfilesFinish),) }
    @property
    def when_profiles_finish(self) -> "ProfilesFinish":
        """When Profiles Converge - the action to be carried out if targeting has converged."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_when_profiles_finish_metadata)

    _set_when_profiles_finish_metadata = { "offset" : _set_when_profiles_finish_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ProfilesFinish),) }
    @when_profiles_finish.setter
    def when_profiles_finish(self, value:"ProfilesFinish") -> None:
        return self._intf.set_property(MCSTargetSequence._metadata, MCSTargetSequence._set_when_profiles_finish_metadata, value)

    _get_continue_on_failure_metadata = { "offset" : _get_continue_on_failure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def continue_on_failure(self) -> bool:
        """Continue if profiles don't converge - if true, the target sequence continues if a profile fails to converge; otherwise, the MCS will stop upon the failure of a search profile."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_continue_on_failure_metadata)

    _set_continue_on_failure_metadata = { "offset" : _set_continue_on_failure_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @continue_on_failure.setter
    def continue_on_failure(self, value:bool) -> None:
        return self._intf.set_property(MCSTargetSequence._metadata, MCSTargetSequence._set_continue_on_failure_metadata, value)

    _get_segments_metadata = { "offset" : _get_segments_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segments(self) -> "MCSSegmentCollection":
        """Return the segments contained within the target sequence."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_segments_metadata)

    _get_profiles_metadata = { "offset" : _get_profiles_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def profiles(self) -> "ProfileCollection":
        """Return the profiles used within the target sequence."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_profiles_metadata)

    _apply_profiles_metadata = { "offset" : _apply_profiles_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_profiles(self) -> None:
        """Apply Changes - applies the current values of search profiles' controls and the changes specified by the segment configuration profiles to the segments within the target sequence."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._apply_profiles_metadata, )

    _reset_profiles_metadata = { "offset" : _reset_profiles_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def reset_profiles(self) -> None:
        """Reset - resets the controls of the search profiles to the segments' values."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._reset_profiles_metadata, )

    _apply_profile_metadata = { "offset" : _apply_profile_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IProfile"),) }
    def apply_profile(self, profile:"IProfile") -> None:
        """Apply Changes - applies the current values of specified profile to the segments within the target sequence."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._apply_profile_metadata, profile)

    _reset_profile_metadata = { "offset" : _reset_profile_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IProfile"),) }
    def reset_profile(self, profile:"IProfile") -> None:
        """Reset - resets the current values of specified profile."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._reset_profile_metadata, profile)

    _apply_profile_by_name_metadata = { "offset" : _apply_profile_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def apply_profile_by_name(self, profile:str) -> None:
        """Apply Changes - applies the current values of specified profile to the segments within the target sequence."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._apply_profile_by_name_metadata, profile)

    _reset_profile_by_name_metadata = { "offset" : _reset_profile_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def reset_profile_by_name(self, profile:str) -> None:
        """Reset - resets the current values of specified profile."""
        return self._intf.invoke(MCSTargetSequence._metadata, MCSTargetSequence._reset_profile_by_name_metadata, profile)

    _get_reset_inner_targeters_metadata = { "offset" : _get_reset_inner_targeters_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reset_inner_targeters(self) -> bool:
        """If true, inner target sequences will have their profiles reset before each run."""
        return self._intf.get_property(MCSTargetSequence._metadata, MCSTargetSequence._get_reset_inner_targeters_metadata)

    _set_reset_inner_targeters_metadata = { "offset" : _set_reset_inner_targeters_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reset_inner_targeters.setter
    def reset_inner_targeters(self, value:bool) -> None:
        return self._intf.set_property(MCSTargetSequence._metadata, MCSTargetSequence._set_reset_inner_targeters_metadata, value)

    _property_names[action] = "action"
    _property_names[when_profiles_finish] = "when_profiles_finish"
    _property_names[continue_on_failure] = "continue_on_failure"
    _property_names[segments] = "segments"
    _property_names[profiles] = "profiles"
    _property_names[reset_inner_targeters] = "reset_inner_targeters"

    def __init__(self, source_object=None):
        """Construct an object of type MCSTargetSequence."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSTargetSequence)
        IMCSSegment.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IMCSSegment._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSTargetSequence, [MCSTargetSequence, IMCSSegment, IRuntimeTypeInfoProvider, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5275189599605526062, 2875478924429173914), MCSTargetSequence)
agcls.AgTypeNameMap["MCSTargetSequence"] = MCSTargetSequence

class ProfileCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a list of target sequence profiles."""

    _num_methods = 14
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _item_method_offset = 2
    _get__new_enum_method_offset = 3
    _get_count_method_offset = 4
    _get_available_profiles_method_offset = 5
    _remove_method_offset = 6
    _remove_all_method_offset = 7
    _get_provide_runtime_type_info_method_offset = 8
    _cut_method_offset = 9
    _paste_method_offset = 10
    _insert_copy_method_offset = 11
    _add2_method_offset = 12
    _get_item_by_index_method_offset = 13
    _get_item_by_name_method_offset = 14
    _metadata = {
        "iid_data" : (5630196485976636884, 6542187252655594407),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileCollection)
    def __iter__(self):
        """Create an iterator for the ProfileCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IProfile":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, profile_name:str) -> "IProfile":
        """Add a profile."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._add_metadata, profile_name, OutArg())

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "IProfile":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ProfileCollection._metadata, ProfileCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ProfileCollection._metadata, ProfileCollection._get_count_metadata)

    _get_available_profiles_metadata = { "offset" : _get_available_profiles_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def available_profiles(self) -> list:
        """Return a list of available profiles."""
        return self._intf.get_property(ProfileCollection._metadata, ProfileCollection._get_available_profiles_metadata)

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_profile_name:typing.Any) -> None:
        """Remove an item from the profile collection."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._remove_metadata, index_or_profile_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all profiles from the profile collection."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._remove_all_metadata, )

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ProfileCollection._metadata, ProfileCollection._get_provide_runtime_type_info_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the profile into the clipboard and removes profile from the list."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (agcom.Variant, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.EnumArg(ProfileInsertDirection), agmarshall.InterfaceOutArg,) }
    def paste(self, index_or_name:typing.Any, direction:"ProfileInsertDirection") -> "IProfile":
        """Pastes the profile from the clipboard and inserts into the list."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._paste_metadata, index_or_name, direction, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, agcom.Variant, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IProfile"), agmarshall.VariantArg, agmarshall.EnumArg(ProfileInsertDirection), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, profile:"IProfile", index_or_name:typing.Any, direction:"ProfileInsertDirection") -> "IProfile":
        """Copy the profile and inserts the copy into the list."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._insert_copy_metadata, profile, index_or_name, direction, OutArg())

    _add2_metadata = { "offset" : _add2_method_offset,
            "arg_types" : (agcom.BSTR, agcom.Variant, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg, agmarshall.EnumArg(ProfileInsertDirection), agmarshall.InterfaceOutArg,) }
    def add2(self, profile_name:str, index_or_name:typing.Any, direction:"ProfileInsertDirection") -> "IProfile":
        """Add a profile."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._add2_metadata, profile_name, index_or_name, direction, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "IProfile":
        """Retrieve a profile from the collection by index."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "IProfile":
        """Retrieve a profile from the collection by name."""
        return self._intf.invoke(ProfileCollection._metadata, ProfileCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[available_profiles] = "available_profiles"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileCollection, [ProfileCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5143990449118478455, 3349457320014041742), ProfileCollection)
agcls.AgTypeNameMap["ProfileCollection"] = ProfileCollection

class MCSOptions(SupportsDeleteCallback):
    """Properties for the MCS Options."""

    _num_methods = 37
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_draw_trajectory_in_2d_method_offset = 1
    _set_draw_trajectory_in_2d_method_offset = 2
    _get_draw_trajectory_in_3d_method_offset = 3
    _set_draw_trajectory_in_3d_method_offset = 4
    _get_update_animation_time_for_all_objects_method_offset = 5
    _set_update_animation_time_for_all_objects_method_offset = 6
    _get_clear_draw_while_calculating_graphics_before_each_run_method_offset = 7
    _set_clear_draw_while_calculating_graphics_before_each_run_method_offset = 8
    _get_clear_additional_b_plane_points_method_offset = 9
    _set_clear_additional_b_plane_points_method_offset = 10
    _get_propagate_on_apply_method_offset = 11
    _set_propagate_on_apply_method_offset = 12
    _get_enable_trajectory_segment_colors_method_offset = 13
    _set_enable_trajectory_segment_colors_method_offset = 14
    _get_save_numbers_in_raw_format_method_offset = 15
    _set_save_numbers_in_raw_format_method_offset = 16
    _get_stopping_condition_time_tolerance_method_offset = 17
    _set_stopping_condition_time_tolerance_method_offset = 18
    _get_enable_segment_controls_method_offset = 19
    _set_enable_segment_controls_method_offset = 20
    _get_enable_segment_results_method_offset = 21
    _set_enable_segment_results_method_offset = 22
    _get_enable_logging_method_offset = 23
    _set_enable_logging_method_offset = 24
    _get_graphics_update_rate_method_offset = 25
    _set_graphics_update_rate_method_offset = 26
    _get_promote_controls_method_offset = 27
    _set_promote_controls_method_offset = 28
    _get_use_nominal_settings_method_offset = 29
    _set_use_nominal_settings_method_offset = 30
    _get_min_ephem_step_method_offset = 31
    _set_min_ephem_step_method_offset = 32
    _get_generate_ephemeris_method_offset = 33
    _set_generate_ephemeris_method_offset = 34
    _get_user_variables_method_offset = 35
    _get_smart_run_mode_method_offset = 36
    _set_smart_run_mode_method_offset = 37
    _metadata = {
        "iid_data" : (4995434399239591698, 15701662039751640989),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSOptions)

    _get_draw_trajectory_in_2d_metadata = { "offset" : _get_draw_trajectory_in_2d_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def draw_trajectory_in_2d(self) -> bool:
        """If true, Astrogator will draw the trajectory in the 2D Graphics windows as the ephemeris is calculated during the current run."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_draw_trajectory_in_2d_metadata)

    _set_draw_trajectory_in_2d_metadata = { "offset" : _set_draw_trajectory_in_2d_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @draw_trajectory_in_2d.setter
    def draw_trajectory_in_2d(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_draw_trajectory_in_2d_metadata, value)

    _get_draw_trajectory_in_3d_metadata = { "offset" : _get_draw_trajectory_in_3d_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def draw_trajectory_in_3d(self) -> bool:
        """If true, Astrogator will draw the trajectory in the 3D Graphics windows as the ephemeris is calculated during the current run."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_draw_trajectory_in_3d_metadata)

    _set_draw_trajectory_in_3d_metadata = { "offset" : _set_draw_trajectory_in_3d_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @draw_trajectory_in_3d.setter
    def draw_trajectory_in_3d(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_draw_trajectory_in_3d_metadata, value)

    _get_update_animation_time_for_all_objects_metadata = { "offset" : _get_update_animation_time_for_all_objects_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def update_animation_time_for_all_objects(self) -> bool:
        """If true, all other objects will be animated so that they appear at the proper position for the time being computed as the trajectory is calculated."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_update_animation_time_for_all_objects_metadata)

    _set_update_animation_time_for_all_objects_metadata = { "offset" : _set_update_animation_time_for_all_objects_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @update_animation_time_for_all_objects.setter
    def update_animation_time_for_all_objects(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_update_animation_time_for_all_objects_metadata, value)

    _get_clear_draw_while_calculating_graphics_before_each_run_metadata = { "offset" : _get_clear_draw_while_calculating_graphics_before_each_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def clear_draw_while_calculating_graphics_before_each_run(self) -> bool:
        """If true, Astrogator will automatically clear all target iteration graphics of the previous run - in all graphics windows - before the current run draws new calculations."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_clear_draw_while_calculating_graphics_before_each_run_metadata)

    _set_clear_draw_while_calculating_graphics_before_each_run_metadata = { "offset" : _set_clear_draw_while_calculating_graphics_before_each_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @clear_draw_while_calculating_graphics_before_each_run.setter
    def clear_draw_while_calculating_graphics_before_each_run(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_clear_draw_while_calculating_graphics_before_each_run_metadata, value)

    _get_clear_additional_b_plane_points_metadata = { "offset" : _get_clear_additional_b_plane_points_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def clear_additional_b_plane_points(self) -> bool:
        """If true, Astrogator will clear all additional B-Plane points from any previous run - in all graphics windows - before the current run."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_clear_additional_b_plane_points_metadata)

    _set_clear_additional_b_plane_points_metadata = { "offset" : _set_clear_additional_b_plane_points_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @clear_additional_b_plane_points.setter
    def clear_additional_b_plane_points(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_clear_additional_b_plane_points_metadata, value)

    _get_propagate_on_apply_metadata = { "offset" : _get_propagate_on_apply_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def propagate_on_apply(self) -> bool:
        """If true, Astrogator will propagate trajectories whenever you click OK or Apply on the Orbit page. If you want to close the Properties Browser for the satellite without running the MCS, make certain this option is disabled."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_propagate_on_apply_metadata)

    _set_propagate_on_apply_metadata = { "offset" : _set_propagate_on_apply_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @propagate_on_apply.setter
    def propagate_on_apply(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_propagate_on_apply_metadata, value)

    _get_enable_trajectory_segment_colors_metadata = { "offset" : _get_enable_trajectory_segment_colors_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_trajectory_segment_colors(self) -> bool:
        """If true, trajectory segments are displayed in the 2D Graphics window in the colors selected for the respective segments; otherwise the color of the trajectory is defined by the 2D Graphics Attributes page."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_enable_trajectory_segment_colors_metadata)

    _set_enable_trajectory_segment_colors_metadata = { "offset" : _set_enable_trajectory_segment_colors_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_trajectory_segment_colors.setter
    def enable_trajectory_segment_colors(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_enable_trajectory_segment_colors_metadata, value)

    _get_save_numbers_in_raw_format_metadata = { "offset" : _get_save_numbers_in_raw_format_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def save_numbers_in_raw_format(self) -> bool:
        """If true, Astrogator will store satellite information in binary format - to preserve the maximum amount of precision."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_save_numbers_in_raw_format_metadata)

    _set_save_numbers_in_raw_format_metadata = { "offset" : _set_save_numbers_in_raw_format_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @save_numbers_in_raw_format.setter
    def save_numbers_in_raw_format(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_save_numbers_in_raw_format_metadata, value)

    _get_stopping_condition_time_tolerance_metadata = { "offset" : _get_stopping_condition_time_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stopping_condition_time_tolerance(self) -> float:
        """Get or set the time tolerance, which will be applied with respect to desired trip values throughout the MCS. If this value is set to zero, time tolerance will not be applied."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_stopping_condition_time_tolerance_metadata)

    _set_stopping_condition_time_tolerance_metadata = { "offset" : _set_stopping_condition_time_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stopping_condition_time_tolerance.setter
    def stopping_condition_time_tolerance(self, value:float) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_stopping_condition_time_tolerance_metadata, value)

    _get_enable_segment_controls_metadata = { "offset" : _get_enable_segment_controls_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_segment_controls(self) -> bool:
        """If true, Astrogator will automatically add independent variables to differential correctors."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_enable_segment_controls_metadata)

    _set_enable_segment_controls_metadata = { "offset" : _set_enable_segment_controls_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_segment_controls.setter
    def enable_segment_controls(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_enable_segment_controls_metadata, value)

    _get_enable_segment_results_metadata = { "offset" : _get_enable_segment_results_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_segment_results(self) -> bool:
        """If true, Astrogator will automatically add dependent variables to differential correctors."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_enable_segment_results_metadata)

    _set_enable_segment_results_metadata = { "offset" : _set_enable_segment_results_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_segment_results.setter
    def enable_segment_results(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_enable_segment_results_metadata, value)

    _get_enable_logging_metadata = { "offset" : _get_enable_logging_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_logging(self) -> bool:
        """If true, target sequences can be set to produce 'run history' log files for differential corrector profiles. By default, a target sequence does not produce a log file."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_enable_logging_metadata)

    _set_enable_logging_metadata = { "offset" : _set_enable_logging_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_logging.setter
    def enable_logging(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_enable_logging_metadata, value)

    _get_graphics_update_rate_metadata = { "offset" : _get_graphics_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def graphics_update_rate(self) -> float:
        """Get or set the rate (between 0 and 1) at which to update graphics. Dimensionless."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_graphics_update_rate_metadata)

    _set_graphics_update_rate_metadata = { "offset" : _set_graphics_update_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @graphics_update_rate.setter
    def graphics_update_rate(self, value:float) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_graphics_update_rate_metadata, value)

    _get_promote_controls_metadata = { "offset" : _get_promote_controls_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def promote_controls(self) -> bool:
        """If true, a target sequence will be able to affect controls and results within a nested target sequence in addition to its own."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_promote_controls_metadata)

    _set_promote_controls_metadata = { "offset" : _set_promote_controls_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @promote_controls.setter
    def promote_controls(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_promote_controls_metadata, value)

    _get_use_nominal_settings_metadata = { "offset" : _get_use_nominal_settings_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_nominal_settings(self) -> bool:
        """If true, components or segments that are modified by a target sequence will be restored to their nominal values as soon as the target sequence completes its run."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_use_nominal_settings_metadata)

    _set_use_nominal_settings_metadata = { "offset" : _set_use_nominal_settings_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_nominal_settings.setter
    def use_nominal_settings(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_use_nominal_settings_metadata, value)

    _get_min_ephem_step_metadata = { "offset" : _get_min_ephem_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_ephem_step(self) -> float:
        """Get or set the minimum step size for saving ephemeris. Uses Time Dimension."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_min_ephem_step_metadata)

    _set_min_ephem_step_metadata = { "offset" : _set_min_ephem_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_ephem_step.setter
    def min_ephem_step(self, value:float) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_min_ephem_step_metadata, value)

    _get_generate_ephemeris_metadata = { "offset" : _get_generate_ephemeris_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def generate_ephemeris(self) -> bool:
        """If true, Astrogator will generate ephemeris."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_generate_ephemeris_metadata)

    _set_generate_ephemeris_metadata = { "offset" : _set_generate_ephemeris_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @generate_ephemeris.setter
    def generate_ephemeris(self, value:bool) -> None:
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_generate_ephemeris_metadata, value)

    _get_user_variables_metadata = { "offset" : _get_user_variables_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_variables(self) -> "UserVariableDefinitionCollection":
        """Interface used to add/remove user variables."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_user_variables_metadata)

    _get_smart_run_mode_metadata = { "offset" : _get_smart_run_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SmartRunMode),) }
    @property
    def smart_run_mode(self) -> "SmartRunMode":
        """Control whether the run will attempt to only run changed segments."""
        return self._intf.get_property(MCSOptions._metadata, MCSOptions._get_smart_run_mode_metadata)

    _set_smart_run_mode_metadata = { "offset" : _set_smart_run_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SmartRunMode),) }
    @smart_run_mode.setter
    def smart_run_mode(self, value:"SmartRunMode") -> None:
        """Control whether the run will attempt to only run changed segments."""
        return self._intf.set_property(MCSOptions._metadata, MCSOptions._set_smart_run_mode_metadata, value)

    _property_names[draw_trajectory_in_2d] = "draw_trajectory_in_2d"
    _property_names[draw_trajectory_in_3d] = "draw_trajectory_in_3d"
    _property_names[update_animation_time_for_all_objects] = "update_animation_time_for_all_objects"
    _property_names[clear_draw_while_calculating_graphics_before_each_run] = "clear_draw_while_calculating_graphics_before_each_run"
    _property_names[clear_additional_b_plane_points] = "clear_additional_b_plane_points"
    _property_names[propagate_on_apply] = "propagate_on_apply"
    _property_names[enable_trajectory_segment_colors] = "enable_trajectory_segment_colors"
    _property_names[save_numbers_in_raw_format] = "save_numbers_in_raw_format"
    _property_names[stopping_condition_time_tolerance] = "stopping_condition_time_tolerance"
    _property_names[enable_segment_controls] = "enable_segment_controls"
    _property_names[enable_segment_results] = "enable_segment_results"
    _property_names[enable_logging] = "enable_logging"
    _property_names[graphics_update_rate] = "graphics_update_rate"
    _property_names[promote_controls] = "promote_controls"
    _property_names[use_nominal_settings] = "use_nominal_settings"
    _property_names[min_ephem_step] = "min_ephem_step"
    _property_names[generate_ephemeris] = "generate_ephemeris"
    _property_names[user_variables] = "user_variables"
    _property_names[smart_run_mode] = "smart_run_mode"

    def __init__(self, source_object=None):
        """Construct an object of type MCSOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSOptions)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSOptions, [MCSOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5252079360558931739, 420969178435848603), MCSOptions)
agcls.AgTypeNameMap["MCSOptions"] = MCSOptions

class CalculationObjectCollection(SupportsDeleteCallback):
    """Collection of calculation objects."""

    _num_methods = 10
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _item_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _cut_method_offset = 6
    _paste_method_offset = 7
    _insert_copy_method_offset = 8
    _get_item_by_index_method_offset = 9
    _get_item_by_name_method_offset = 10
    _metadata = {
        "iid_data" : (4871526303947963367, 9557979883536836749),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CalculationObjectCollection)
    def __iter__(self):
        """Create an iterator for the CalculationObjectCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IComponentInfo":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, name:str) -> "IComponentInfo":
        """Add a calc object to the collection."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._add_metadata, name, OutArg())

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "IComponentInfo":
        """Return a calc object."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._item_metadata, index_or_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a calc object from the collection."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(CalculationObjectCollection._metadata, CalculationObjectCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(CalculationObjectCollection._metadata, CalculationObjectCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy a calc object to the clipboard and removes the calc object from the list."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "IComponentInfo":
        """Pastes a calc object from the clipboard into the list."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, calc_obj:"IComponentInfo") -> "IComponentInfo":
        """Copy a calc object and inserts the copy into the list."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._insert_copy_metadata, calc_obj, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "IComponentInfo":
        """Retrieve a calc object found by the index."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "IComponentInfo":
        """Retrieve a calc object found by the name."""
        return self._intf.invoke(CalculationObjectCollection._metadata, CalculationObjectCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type CalculationObjectCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CalculationObjectCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CalculationObjectCollection, [CalculationObjectCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5427828449804903932, 12224863713293115564), CalculationObjectCollection)
agcls.AgTypeNameMap["CalculationObjectCollection"] = CalculationObjectCollection

class ConstraintCollection(SupportsDeleteCallback):
    """The list of constraints assigned to a stopping condition."""

    _num_methods = 10
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _item_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _cut_method_offset = 6
    _paste_method_offset = 7
    _insert_copy_method_offset = 8
    _get_item_by_index_method_offset = 9
    _get_item_by_name_method_offset = 10
    _metadata = {
        "iid_data" : (5396110646366435143, 4493176677956963970),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ConstraintCollection)
    def __iter__(self):
        """Create an iterator for the ConstraintCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "AsTriggerCondition":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, result_name:str) -> "AsTriggerCondition":
        """Add a constraint to the collection."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._add_metadata, result_name, OutArg())

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "AsTriggerCondition":
        """Iterate through the collection."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._item_metadata, index_or_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a specified constraint from the collection."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """A property that allows you to enumerate through the collection."""
        return self._intf.get_property(ConstraintCollection._metadata, ConstraintCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ConstraintCollection._metadata, ConstraintCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the constraint into the clipboard and removes the constraint from the list."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "AsTriggerCondition":
        """Pastes the constraint from the clipboard and inserts into the list."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("AsTriggerCondition"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, cond:"AsTriggerCondition") -> "AsTriggerCondition":
        """Copy the constraint and inserts the copy into the list."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._insert_copy_metadata, cond, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "AsTriggerCondition":
        """Retrieve a constraint from the collection by index."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "AsTriggerCondition":
        """Retrieve a constraint from the collection by name."""
        return self._intf.invoke(ConstraintCollection._metadata, ConstraintCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type ConstraintCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ConstraintCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ConstraintCollection, [ConstraintCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4630173644378793429, 7503241363423471795), ConstraintCollection)
agcls.AgTypeNameMap["ConstraintCollection"] = ConstraintCollection

class PluginProperties(SupportsDeleteCallback):
    """Properties of a plugin attitude control."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_property_method_offset = 1
    _set_property_method_offset = 2
    _get_available_properties_method_offset = 3
    _metadata = {
        "iid_data" : (5256416044241565756, 10938286104523749517),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PluginProperties)

    _get_property_metadata = { "offset" : _get_property_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg,) }
    def get_property(self, path:str) -> typing.Any:
        """Get a property."""
        return self._intf.invoke(PluginProperties._metadata, PluginProperties._get_property_metadata, path, OutArg())

    _set_property_metadata = { "offset" : _set_property_method_offset,
            "arg_types" : (agcom.BSTR, agcom.Variant,),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg,) }
    def set_property(self, path:str, property_value:typing.Any) -> None:
        """Set a property."""
        return self._intf.invoke(PluginProperties._metadata, PluginProperties._set_property_metadata, path, property_value)

    _get_available_properties_metadata = { "offset" : _get_available_properties_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def available_properties(self) -> list:
        """Return an array of all available properties."""
        return self._intf.get_property(PluginProperties._metadata, PluginProperties._get_available_properties_metadata)

    _property_names[available_properties] = "available_properties"

    def __init__(self, source_object=None):
        """Construct an object of type PluginProperties."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PluginProperties)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PluginProperties, [PluginProperties, ])

agcls.AgClassCatalog.add_catalog_entry((4832164181540462688, 9736795849403081643), PluginProperties)
agcls.AgTypeNameMap["PluginProperties"] = PluginProperties

class ProfileSearchPlugin(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties of a plugin search profile."""

    _num_methods = 9
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_controls_method_offset = 1
    _get_results_method_offset = 2
    _get_plugin_config_method_offset = 3
    _get_plugin_identifier_method_offset = 4
    _get_scripting_tool_method_offset = 5
    _get_reset_controls_before_run_method_offset = 6
    _set_reset_controls_before_run_method_offset = 7
    _get_targeter_graphs_method_offset = 8
    _get_log_file_method_offset = 9
    _metadata = {
        "iid_data" : (4989321574453629085, 18383769424312266673),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileSearchPlugin)

    _get_controls_metadata = { "offset" : _get_controls_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def controls(self) -> "SearchPluginControlCollection":
        """Get the selected control parameters."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_controls_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "SearchPluginResultCollection":
        """Get the selected equality constraints."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_results_metadata)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_plugin_config_metadata)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get the plugin identifier."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_plugin_identifier_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_scripting_tool_metadata)

    _get_reset_controls_before_run_metadata = { "offset" : _get_reset_controls_before_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reset_controls_before_run(self) -> bool:
        """Reset controls before each run."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_reset_controls_before_run_metadata)

    _set_reset_controls_before_run_metadata = { "offset" : _set_reset_controls_before_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reset_controls_before_run.setter
    def reset_controls_before_run(self, value:bool) -> None:
        return self._intf.set_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._set_reset_controls_before_run_metadata, value)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_targeter_graphs_metadata)

    _get_log_file_metadata = { "offset" : _get_log_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def log_file(self) -> str:
        """Name of the log file for this profile."""
        return self._intf.get_property(ProfileSearchPlugin._metadata, ProfileSearchPlugin._get_log_file_metadata)

    _property_names[controls] = "controls"
    _property_names[results] = "results"
    _property_names[plugin_config] = "plugin_config"
    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[reset_controls_before_run] = "reset_controls_before_run"
    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[log_file] = "log_file"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileSearchPlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileSearchPlugin)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileSearchPlugin, [ProfileSearchPlugin, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5288551634889688931, 6097150253307945909), ProfileSearchPlugin)
agcls.AgTypeNameMap["ProfileSearchPlugin"] = ProfileSearchPlugin

class TargeterGraph(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Targeter Graph."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_generate_on_run_method_offset = 3
    _set_generate_on_run_method_offset = 4
    _get_user_comment_method_offset = 5
    _set_user_comment_method_offset = 6
    _get_show_label_iterations_method_offset = 7
    _set_show_label_iterations_method_offset = 8
    _get_show_desired_value_method_offset = 9
    _set_show_desired_value_method_offset = 10
    _get_show_tolerance_band_method_offset = 11
    _set_show_tolerance_band_method_offset = 12
    _get_independent_variable_method_offset = 13
    _set_independent_variable_method_offset = 14
    _get_active_controls_method_offset = 15
    _get_results_method_offset = 16
    _metadata = {
        "iid_data" : (5135924380442436999, 7678843553599670682),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraph)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get or set the name of the graph."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        """Get or set the name of the graph."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_name_metadata, value)

    _get_generate_on_run_metadata = { "offset" : _get_generate_on_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def generate_on_run(self) -> bool:
        """Generate the graph while MCS is being run."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_generate_on_run_metadata)

    _set_generate_on_run_metadata = { "offset" : _set_generate_on_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @generate_on_run.setter
    def generate_on_run(self, value:bool) -> None:
        """Generate the graph while MCS is being run."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_generate_on_run_metadata, value)

    _get_user_comment_metadata = { "offset" : _get_user_comment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_comment(self) -> str:
        """User Comment."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_user_comment_metadata)

    _set_user_comment_metadata = { "offset" : _set_user_comment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_comment.setter
    def user_comment(self, value:str) -> None:
        """User Comment."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_user_comment_metadata, value)

    _get_show_label_iterations_metadata = { "offset" : _get_show_label_iterations_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_label_iterations(self) -> bool:
        """Label each of the points on the graph labeled according to its iteration number."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_show_label_iterations_metadata)

    _set_show_label_iterations_metadata = { "offset" : _set_show_label_iterations_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_label_iterations.setter
    def show_label_iterations(self, value:bool) -> None:
        """Label each of the points on the graph labeled according to its iteration number."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_show_label_iterations_metadata, value)

    _get_show_desired_value_metadata = { "offset" : _get_show_desired_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_desired_value(self) -> bool:
        """Show the desired equality constraint value(s) on the graph. Not applicable to SNOPT and IPOPT search profiles."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_show_desired_value_metadata)

    _set_show_desired_value_metadata = { "offset" : _set_show_desired_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_desired_value.setter
    def show_desired_value(self, value:bool) -> None:
        """Show the desired equality constraint value(s) on the graph. Not applicable to SNOPT and IPOPT search profiles."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_show_desired_value_metadata, value)

    _get_show_tolerance_band_metadata = { "offset" : _get_show_tolerance_band_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_tolerance_band(self) -> bool:
        """Show the tolerance band on the graph. Not applicable to SNOPT and IPOPT search profiles."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_show_tolerance_band_metadata)

    _set_show_tolerance_band_metadata = { "offset" : _set_show_tolerance_band_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_tolerance_band.setter
    def show_tolerance_band(self, value:bool) -> None:
        """Show the tolerance band on the graph. Not applicable to SNOPT and IPOPT search profiles."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_show_tolerance_band_metadata, value)

    _get_independent_variable_metadata = { "offset" : _get_independent_variable_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def independent_variable(self) -> str:
        """Select the graph's X axis."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_independent_variable_metadata)

    _set_independent_variable_metadata = { "offset" : _set_independent_variable_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @independent_variable.setter
    def independent_variable(self, value:str) -> None:
        """Select the graph's X axis."""
        return self._intf.set_property(TargeterGraph._metadata, TargeterGraph._set_independent_variable_metadata, value)

    _get_active_controls_metadata = { "offset" : _get_active_controls_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def active_controls(self) -> "TargeterGraphActiveControlCollection":
        """Active Controls."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_active_controls_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "TargeterGraphResultCollection":
        """Results."""
        return self._intf.get_property(TargeterGraph._metadata, TargeterGraph._get_results_metadata)

    _property_names[name] = "name"
    _property_names[generate_on_run] = "generate_on_run"
    _property_names[user_comment] = "user_comment"
    _property_names[show_label_iterations] = "show_label_iterations"
    _property_names[show_desired_value] = "show_desired_value"
    _property_names[show_tolerance_band] = "show_tolerance_band"
    _property_names[independent_variable] = "independent_variable"
    _property_names[active_controls] = "active_controls"
    _property_names[results] = "results"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraph."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraph)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraph, [TargeterGraph, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4820292145119127894, 2993481562376072357), TargeterGraph)
agcls.AgTypeNameMap["TargeterGraph"] = TargeterGraph

class TargeterGraphCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The list of User Variables accessed through the Driver."""

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _add_graph_method_offset = 4
    _remove_graph_method_offset = 5
    _get_provide_runtime_type_info_method_offset = 6
    _cut_method_offset = 7
    _paste_method_offset = 8
    _insert_copy_method_offset = 9
    _get_item_by_index_method_offset = 10
    _get_item_by_name_method_offset = 11
    _metadata = {
        "iid_data" : (4666281358055310374, 1442486553483265713),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraphCollection)
    def __iter__(self):
        """Create an iterator for the TargeterGraphCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "TargeterGraph":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "TargeterGraph":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(TargeterGraphCollection._metadata, TargeterGraphCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(TargeterGraphCollection._metadata, TargeterGraphCollection._get_count_metadata)

    _add_graph_metadata = { "offset" : _add_graph_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def add_graph(self) -> "TargeterGraph":
        """Add a new targeter graph."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._add_graph_metadata, OutArg())

    _remove_graph_metadata = { "offset" : _remove_graph_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove_graph(self, index_or_name:typing.Any) -> None:
        """Remove a targeter graph."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._remove_graph_metadata, index_or_name)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(TargeterGraphCollection._metadata, TargeterGraphCollection._get_provide_runtime_type_info_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy a targeter graph to the clipboard and removes the targeter graph from the list."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "TargeterGraph":
        """Pastes a targeter graph from the clipboard into the list."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("TargeterGraph"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, graph:"TargeterGraph") -> "TargeterGraph":
        """Copy a targeter graph and inserts the copy into the list."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._insert_copy_metadata, graph, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "TargeterGraph":
        """Retrieve a targeter graph from the collection by index."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "TargeterGraph":
        """Retrieve a targeter graph from the collection by name."""
        return self._intf.invoke(TargeterGraphCollection._metadata, TargeterGraphCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraphCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraphCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraphCollection, [TargeterGraphCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5713818234225934544, 4609064603796981650), TargeterGraphCollection)
agcls.AgTypeNameMap["TargeterGraphCollection"] = TargeterGraphCollection

class TargeterGraphResultCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Targeter graph results."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_provide_runtime_type_info_method_offset = 4
    _metadata = {
        "iid_data" : (5681214531064451260, 3542062518212208806),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraphResultCollection)
    def __iter__(self):
        """Create an iterator for the TargeterGraphResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "TargeterGraphResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "TargeterGraphResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(TargeterGraphResultCollection._metadata, TargeterGraphResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(TargeterGraphResultCollection._metadata, TargeterGraphResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(TargeterGraphResultCollection._metadata, TargeterGraphResultCollection._get_count_metadata)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(TargeterGraphResultCollection._metadata, TargeterGraphResultCollection._get_provide_runtime_type_info_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraphResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraphResultCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraphResultCollection, [TargeterGraphResultCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4675941918306799033, 16991213643032778938), TargeterGraphResultCollection)
agcls.AgTypeNameMap["TargeterGraphResultCollection"] = TargeterGraphResultCollection

class TargeterGraphActiveControlCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Targeter graph active controls."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_provide_runtime_type_info_method_offset = 4
    _metadata = {
        "iid_data" : (5718318377038943766, 11707308167199207819),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraphActiveControlCollection)
    def __iter__(self):
        """Create an iterator for the TargeterGraphActiveControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "TargeterGraphActiveControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "TargeterGraphActiveControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(TargeterGraphActiveControlCollection._metadata, TargeterGraphActiveControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(TargeterGraphActiveControlCollection._metadata, TargeterGraphActiveControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(TargeterGraphActiveControlCollection._metadata, TargeterGraphActiveControlCollection._get_count_metadata)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(TargeterGraphActiveControlCollection._metadata, TargeterGraphActiveControlCollection._get_provide_runtime_type_info_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraphActiveControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraphActiveControlCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraphActiveControlCollection, [TargeterGraphActiveControlCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5060958647911646068, 16483538695082057382), TargeterGraphActiveControlCollection)
agcls.AgTypeNameMap["TargeterGraphActiveControlCollection"] = TargeterGraphActiveControlCollection

class TargeterGraphActiveControl(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for targeter graph active control."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _get_parent_name_method_offset = 2
    _get_show_graph_value_method_offset = 3
    _set_show_graph_value_method_offset = 4
    _get_line_color_method_offset = 5
    _set_line_color_method_offset = 6
    _get_point_style_method_offset = 7
    _set_point_style_method_offset = 8
    _get_y_axis_method_offset = 9
    _set_y_axis_method_offset = 10
    _metadata = {
        "iid_data" : (5193288564717621701, 9284685105260980413),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraphActiveControl)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the active control."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the segment or component to which the element belongs."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_parent_name_metadata)

    _get_show_graph_value_metadata = { "offset" : _get_show_graph_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_graph_value(self) -> bool:
        """Show the value."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_show_graph_value_metadata)

    _set_show_graph_value_metadata = { "offset" : _set_show_graph_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_graph_value.setter
    def show_graph_value(self, value:bool) -> None:
        """Show the value."""
        return self._intf.set_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._set_show_graph_value_metadata, value)

    _get_line_color_metadata = { "offset" : _get_line_color_method_offset,
            "arg_types" : (POINTER(agcom.OLE_COLOR),),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @property
    def line_color(self) -> agcolor.Color:
        """Line Color."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_line_color_metadata)

    _set_line_color_metadata = { "offset" : _set_line_color_method_offset,
            "arg_types" : (agcom.OLE_COLOR,),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @line_color.setter
    def line_color(self, value:agcolor.Color) -> None:
        """Line Color."""
        return self._intf.set_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._set_line_color_metadata, value)

    _get_point_style_metadata = { "offset" : _get_point_style_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def point_style(self) -> str:
        """Point Style."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_point_style_metadata)

    _set_point_style_metadata = { "offset" : _set_point_style_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @point_style.setter
    def point_style(self, value:str) -> None:
        """Point Style."""
        return self._intf.set_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._set_point_style_metadata, value)

    _get_y_axis_metadata = { "offset" : _get_y_axis_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def y_axis(self) -> str:
        """Select whether to display the control's value range on the left or right side of the graph."""
        return self._intf.get_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._get_y_axis_metadata)

    _set_y_axis_metadata = { "offset" : _set_y_axis_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @y_axis.setter
    def y_axis(self, value:str) -> None:
        """Select whether to display the control's value range on the left or right side of the graph."""
        return self._intf.set_property(TargeterGraphActiveControl._metadata, TargeterGraphActiveControl._set_y_axis_metadata, value)

    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[show_graph_value] = "show_graph_value"
    _property_names[line_color] = "line_color"
    _property_names[point_style] = "point_style"
    _property_names[y_axis] = "y_axis"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraphActiveControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraphActiveControl)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraphActiveControl, [TargeterGraphActiveControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5123733805731250082, 10040985544979632029), TargeterGraphActiveControl)
agcls.AgTypeNameMap["TargeterGraphActiveControl"] = TargeterGraphActiveControl

class TargeterGraphResult(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for targeter graph result."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _get_parent_name_method_offset = 2
    _get_show_desired_value_method_offset = 3
    _set_show_desired_value_method_offset = 4
    _get_line_color_method_offset = 5
    _set_line_color_method_offset = 6
    _get_point_style_method_offset = 7
    _set_point_style_method_offset = 8
    _get_y_axis_method_offset = 9
    _set_y_axis_method_offset = 10
    _get_graph_option_method_offset = 11
    _set_graph_option_method_offset = 12
    _get_show_tolerance_band_method_offset = 13
    _set_show_tolerance_band_method_offset = 14
    _metadata = {
        "iid_data" : (5079886305028495981, 16269527803066934938),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TargeterGraphResult)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the result."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the segment or component for which this result has been selected."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_parent_name_metadata)

    _get_show_desired_value_metadata = { "offset" : _get_show_desired_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_desired_value(self) -> bool:
        """Show the desired value."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_show_desired_value_metadata)

    _set_show_desired_value_metadata = { "offset" : _set_show_desired_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_desired_value.setter
    def show_desired_value(self, value:bool) -> None:
        """Show the desired value."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_show_desired_value_metadata, value)

    _get_line_color_metadata = { "offset" : _get_line_color_method_offset,
            "arg_types" : (POINTER(agcom.OLE_COLOR),),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @property
    def line_color(self) -> agcolor.Color:
        """Line Color."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_line_color_metadata)

    _set_line_color_metadata = { "offset" : _set_line_color_method_offset,
            "arg_types" : (agcom.OLE_COLOR,),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @line_color.setter
    def line_color(self, value:agcolor.Color) -> None:
        """Line Color."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_line_color_metadata, value)

    _get_point_style_metadata = { "offset" : _get_point_style_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def point_style(self) -> str:
        """Point Style."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_point_style_metadata)

    _set_point_style_metadata = { "offset" : _set_point_style_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @point_style.setter
    def point_style(self, value:str) -> None:
        """Point Style."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_point_style_metadata, value)

    _get_y_axis_metadata = { "offset" : _get_y_axis_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def y_axis(self) -> str:
        """Select whether to display the result's value range on the left or right side of the graph."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_y_axis_metadata)

    _set_y_axis_metadata = { "offset" : _set_y_axis_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @y_axis.setter
    def y_axis(self, value:str) -> None:
        """Select whether to display the result's value range on the left or right side of the graph."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_y_axis_metadata, value)

    _get_graph_option_metadata = { "offset" : _get_graph_option_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GraphOption),) }
    @property
    def graph_option(self) -> "GraphOption":
        """Graph option."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_graph_option_metadata)

    _set_graph_option_metadata = { "offset" : _set_graph_option_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GraphOption),) }
    @graph_option.setter
    def graph_option(self, value:"GraphOption") -> None:
        """Graph option."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_graph_option_metadata, value)

    _get_show_tolerance_band_metadata = { "offset" : _get_show_tolerance_band_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def show_tolerance_band(self) -> bool:
        """Show the tolerance band."""
        return self._intf.get_property(TargeterGraphResult._metadata, TargeterGraphResult._get_show_tolerance_band_metadata)

    _set_show_tolerance_band_metadata = { "offset" : _set_show_tolerance_band_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @show_tolerance_band.setter
    def show_tolerance_band(self, value:bool) -> None:
        """Show the tolerance band."""
        return self._intf.set_property(TargeterGraphResult._metadata, TargeterGraphResult._set_show_tolerance_band_metadata, value)

    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[show_desired_value] = "show_desired_value"
    _property_names[line_color] = "line_color"
    _property_names[point_style] = "point_style"
    _property_names[y_axis] = "y_axis"
    _property_names[graph_option] = "graph_option"
    _property_names[show_tolerance_band] = "show_tolerance_band"

    def __init__(self, source_object=None):
        """Construct an object of type TargeterGraphResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TargeterGraphResult)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TargeterGraphResult, [TargeterGraphResult, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5372818770923136803, 2677805927587744941), TargeterGraphResult)
agcls.AgTypeNameMap["TargeterGraphResult"] = TargeterGraphResult

class ProfileDifferentialCorrector(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Differential Corrector profile."""

    _num_methods = 39
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_control_parameters_method_offset = 1
    _get_results_method_offset = 2
    _get_max_iterations_method_offset = 3
    _set_max_iterations_method_offset = 4
    _get_enable_display_status_method_offset = 5
    _set_enable_display_status_method_offset = 6
    _get_convergence_criteria_method_offset = 7
    _set_convergence_criteria_method_offset = 8
    _get_enable_line_search_method_offset = 9
    _set_enable_line_search_method_offset = 10
    _get_max_line_search_iterations_method_offset = 11
    _set_max_line_search_iterations_method_offset = 12
    _get_line_search_lower_bound_method_offset = 13
    _set_line_search_lower_bound_method_offset = 14
    _get_line_search_upper_bound_method_offset = 15
    _set_line_search_upper_bound_method_offset = 16
    _get_line_search_tolerance_method_offset = 17
    _set_line_search_tolerance_method_offset = 18
    _get_enable_homotopy_method_offset = 19
    _set_enable_homotopy_method_offset = 20
    _get_homotopy_steps_method_offset = 21
    _set_homotopy_steps_method_offset = 22
    _get_derivative_calc_method_method_offset = 23
    _set_derivative_calc_method_method_offset = 24
    _get_clear_corrections_before_run_method_offset = 25
    _set_clear_corrections_before_run_method_offset = 26
    _get_enable_b_plane_nominal_method_offset = 27
    _set_enable_b_plane_nominal_method_offset = 28
    _get_enable_b_plane_perturbations_method_offset = 29
    _set_enable_b_plane_perturbations_method_offset = 30
    _get_draw_perturbation_method_offset = 31
    _set_draw_perturbation_method_offset = 32
    _get_scripting_tool_method_offset = 33
    _get_root_finding_algorithm_method_offset = 34
    _set_root_finding_algorithm_method_offset = 35
    _get_number_of_iterations_method_offset = 36
    _get_targeter_graphs_method_offset = 37
    _get_stop_on_limit_cycle_detection_method_offset = 38
    _set_stop_on_limit_cycle_detection_method_offset = 39
    _metadata = {
        "iid_data" : (4651276936250783348, 17358117410539768209),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileDifferentialCorrector)

    _get_control_parameters_metadata = { "offset" : _get_control_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def control_parameters(self) -> "DifferentialCorrectorControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_control_parameters_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "DifferentialCorrectorResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_results_metadata)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the number of complete iterations of the profile to try before stopping. Dimensionless."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_max_iterations_metadata, value)

    _get_enable_display_status_metadata = { "offset" : _get_enable_display_status_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_display_status(self) -> bool:
        """If true, a page will appear during the targeting run to report the status of the targeting effort in terms of proximity to the desired value for each dependent variable in the profile."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_enable_display_status_metadata)

    _set_enable_display_status_metadata = { "offset" : _set_enable_display_status_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_display_status.setter
    def enable_display_status(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_enable_display_status_metadata, value)

    _get_convergence_criteria_metadata = { "offset" : _get_convergence_criteria_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ConvergenceCriteria),) }
    @property
    def convergence_criteria(self) -> "ConvergenceCriteria":
        """Get or set the convergence criteria."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_convergence_criteria_metadata)

    _set_convergence_criteria_metadata = { "offset" : _set_convergence_criteria_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ConvergenceCriteria),) }
    @convergence_criteria.setter
    def convergence_criteria(self, value:"ConvergenceCriteria") -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_convergence_criteria_metadata, value)

    _get_enable_line_search_metadata = { "offset" : _get_enable_line_search_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_line_search(self) -> bool:
        """If true, the profile will perform a line search."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_enable_line_search_metadata)

    _set_enable_line_search_metadata = { "offset" : _set_enable_line_search_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_line_search.setter
    def enable_line_search(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_enable_line_search_metadata, value)

    _get_max_line_search_iterations_metadata = { "offset" : _get_max_line_search_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_line_search_iterations(self) -> int:
        """Get or set the number of line search iterations to try before stopping. Dimensionless."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_max_line_search_iterations_metadata)

    _set_max_line_search_iterations_metadata = { "offset" : _set_max_line_search_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_line_search_iterations.setter
    def max_line_search_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_max_line_search_iterations_metadata, value)

    _get_line_search_lower_bound_metadata = { "offset" : _get_line_search_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def line_search_lower_bound(self) -> float:
        """Get or set the low boundary for the line search. Dimensionless."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_line_search_lower_bound_metadata)

    _set_line_search_lower_bound_metadata = { "offset" : _set_line_search_lower_bound_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @line_search_lower_bound.setter
    def line_search_lower_bound(self, value:float) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_line_search_lower_bound_metadata, value)

    _get_line_search_upper_bound_metadata = { "offset" : _get_line_search_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def line_search_upper_bound(self) -> float:
        """Get or set the high boundary for the line search. Dimensionless."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_line_search_upper_bound_metadata)

    _set_line_search_upper_bound_metadata = { "offset" : _set_line_search_upper_bound_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @line_search_upper_bound.setter
    def line_search_upper_bound(self, value:float) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_line_search_upper_bound_metadata, value)

    _get_line_search_tolerance_metadata = { "offset" : _get_line_search_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def line_search_tolerance(self) -> float:
        """Get or set the tolerance for the line search. Dimensionless."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_line_search_tolerance_metadata)

    _set_line_search_tolerance_metadata = { "offset" : _set_line_search_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @line_search_tolerance.setter
    def line_search_tolerance(self, value:float) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_line_search_tolerance_metadata, value)

    _get_enable_homotopy_metadata = { "offset" : _get_enable_homotopy_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_homotopy(self) -> bool:
        """If true, the profile will divide the problem into steps to solve it."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_enable_homotopy_metadata)

    _set_enable_homotopy_metadata = { "offset" : _set_enable_homotopy_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_homotopy.setter
    def enable_homotopy(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_enable_homotopy_metadata, value)

    _get_homotopy_steps_metadata = { "offset" : _get_homotopy_steps_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def homotopy_steps(self) -> int:
        """Get or set the number of steps to divide a problem into for a homotopic calculation. Dimensionless - ."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_homotopy_steps_metadata)

    _set_homotopy_steps_metadata = { "offset" : _set_homotopy_steps_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @homotopy_steps.setter
    def homotopy_steps(self, value:int) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_homotopy_steps_metadata, value)

    _get_derivative_calc_method_metadata = { "offset" : _get_derivative_calc_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DerivativeCalculationMethod),) }
    @property
    def derivative_calc_method(self) -> "DerivativeCalculationMethod":
        """Get or set the derivative calculation method."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_derivative_calc_method_metadata)

    _set_derivative_calc_method_metadata = { "offset" : _set_derivative_calc_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DerivativeCalculationMethod),) }
    @derivative_calc_method.setter
    def derivative_calc_method(self, value:"DerivativeCalculationMethod") -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_derivative_calc_method_metadata, value)

    _get_clear_corrections_before_run_metadata = { "offset" : _get_clear_corrections_before_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def clear_corrections_before_run(self) -> bool:
        """Clear Corrections Before Each Run - if true, the differential corrector is automatically reset each time that it is run, discarding information that was computed the last time it was run."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_clear_corrections_before_run_metadata)

    _set_clear_corrections_before_run_metadata = { "offset" : _set_clear_corrections_before_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @clear_corrections_before_run.setter
    def clear_corrections_before_run(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_clear_corrections_before_run_metadata, value)

    _get_enable_b_plane_nominal_metadata = { "offset" : _get_enable_b_plane_nominal_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_b_plane_nominal(self) -> bool:
        """If true, Astrogator will update the display of B-Planes for the nominal run of each iteration during the targeting process."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_enable_b_plane_nominal_metadata)

    _set_enable_b_plane_nominal_metadata = { "offset" : _set_enable_b_plane_nominal_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_b_plane_nominal.setter
    def enable_b_plane_nominal(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_enable_b_plane_nominal_metadata, value)

    _get_enable_b_plane_perturbations_metadata = { "offset" : _get_enable_b_plane_perturbations_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_b_plane_perturbations(self) -> bool:
        """If true, Astrogator will update the display of B-Planes for both of the perturbations of each iteration during the targeting process."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_enable_b_plane_perturbations_metadata)

    _set_enable_b_plane_perturbations_metadata = { "offset" : _set_enable_b_plane_perturbations_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_b_plane_perturbations.setter
    def enable_b_plane_perturbations(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_enable_b_plane_perturbations_metadata, value)

    _get_draw_perturbation_metadata = { "offset" : _get_draw_perturbation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DrawPerturbation),) }
    @property
    def draw_perturbation(self) -> "DrawPerturbation":
        """Define the display of perturbations in the 2D and 3D Graphics windows, if you have set Astrogator to draw while calculating."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_draw_perturbation_metadata)

    _set_draw_perturbation_metadata = { "offset" : _set_draw_perturbation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DrawPerturbation),) }
    @draw_perturbation.setter
    def draw_perturbation(self, value:"DrawPerturbation") -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_draw_perturbation_metadata, value)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_scripting_tool_metadata)

    _get_root_finding_algorithm_metadata = { "offset" : _get_root_finding_algorithm_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RootFindingAlgorithm),) }
    @property
    def root_finding_algorithm(self) -> "RootFindingAlgorithm":
        """Get or set the root-finding algorithm to use."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_root_finding_algorithm_metadata)

    _set_root_finding_algorithm_metadata = { "offset" : _set_root_finding_algorithm_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RootFindingAlgorithm),) }
    @root_finding_algorithm.setter
    def root_finding_algorithm(self, value:"RootFindingAlgorithm") -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_root_finding_algorithm_metadata, value)

    _get_number_of_iterations_metadata = { "offset" : _get_number_of_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def number_of_iterations(self) -> int:
        """Get the number of iterations of the last run."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_number_of_iterations_metadata)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_targeter_graphs_metadata)

    _get_stop_on_limit_cycle_detection_metadata = { "offset" : _get_stop_on_limit_cycle_detection_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_on_limit_cycle_detection(self) -> bool:
        """If true, Astrogator will stop targeting if a limit cycle is detected."""
        return self._intf.get_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._get_stop_on_limit_cycle_detection_metadata)

    _set_stop_on_limit_cycle_detection_metadata = { "offset" : _set_stop_on_limit_cycle_detection_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_on_limit_cycle_detection.setter
    def stop_on_limit_cycle_detection(self, value:bool) -> None:
        return self._intf.set_property(ProfileDifferentialCorrector._metadata, ProfileDifferentialCorrector._set_stop_on_limit_cycle_detection_metadata, value)

    _property_names[control_parameters] = "control_parameters"
    _property_names[results] = "results"
    _property_names[max_iterations] = "max_iterations"
    _property_names[enable_display_status] = "enable_display_status"
    _property_names[convergence_criteria] = "convergence_criteria"
    _property_names[enable_line_search] = "enable_line_search"
    _property_names[max_line_search_iterations] = "max_line_search_iterations"
    _property_names[line_search_lower_bound] = "line_search_lower_bound"
    _property_names[line_search_upper_bound] = "line_search_upper_bound"
    _property_names[line_search_tolerance] = "line_search_tolerance"
    _property_names[enable_homotopy] = "enable_homotopy"
    _property_names[homotopy_steps] = "homotopy_steps"
    _property_names[derivative_calc_method] = "derivative_calc_method"
    _property_names[clear_corrections_before_run] = "clear_corrections_before_run"
    _property_names[enable_b_plane_nominal] = "enable_b_plane_nominal"
    _property_names[enable_b_plane_perturbations] = "enable_b_plane_perturbations"
    _property_names[draw_perturbation] = "draw_perturbation"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[root_finding_algorithm] = "root_finding_algorithm"
    _property_names[number_of_iterations] = "number_of_iterations"
    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[stop_on_limit_cycle_detection] = "stop_on_limit_cycle_detection"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileDifferentialCorrector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileDifferentialCorrector)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileDifferentialCorrector, [ProfileDifferentialCorrector, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5697793952066233454, 6970629070586778798), ProfileDifferentialCorrector)
agcls.AgTypeNameMap["ProfileDifferentialCorrector"] = ProfileDifferentialCorrector

class ProfileScriptingTool(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Scripting Tool profile."""

    _num_methods = 10
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_segment_properties_method_offset = 3
    _get_calculation_objects_method_offset = 4
    _get_parameters_method_offset = 5
    _get_language_type_method_offset = 6
    _set_language_type_method_offset = 7
    _script_text_method_offset = 8
    _copy_to_clipboard_method_offset = 9
    _paste_from_clipboard_method_offset = 10
    _metadata = {
        "iid_data" : (4932992111891026631, 13621962777049563066),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileScriptingTool)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the scripting tool will be used."""
        return self._intf.get_property(ProfileScriptingTool._metadata, ProfileScriptingTool._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(ProfileScriptingTool._metadata, ProfileScriptingTool._set_enable_metadata, value)

    _get_segment_properties_metadata = { "offset" : _get_segment_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segment_properties(self) -> "ScriptingSegmentCollection":
        """Return the collection of the segment properties."""
        return self._intf.get_property(ProfileScriptingTool._metadata, ProfileScriptingTool._get_segment_properties_metadata)

    _get_calculation_objects_metadata = { "offset" : _get_calculation_objects_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_objects(self) -> "ScriptingCalculationObjectCollection":
        """Return the collection of the calc objects."""
        return self._intf.get_property(ProfileScriptingTool._metadata, ProfileScriptingTool._get_calculation_objects_metadata)

    _get_parameters_metadata = { "offset" : _get_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def parameters(self) -> "ScriptingParameterCollection":
        """Return the collection of parameters."""
        return self._intf.get_property(ProfileScriptingTool._metadata, ProfileScriptingTool._get_parameters_metadata)

    _get_language_type_metadata = { "offset" : _get_language_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Language),) }
    @property
    def language_type(self) -> "Language":
        """Get or set the scripting language being used."""
        return self._intf.get_property(ProfileScriptingTool._metadata, ProfileScriptingTool._get_language_type_metadata)

    _set_language_type_metadata = { "offset" : _set_language_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Language),) }
    @language_type.setter
    def language_type(self, value:"Language") -> None:
        return self._intf.set_property(ProfileScriptingTool._metadata, ProfileScriptingTool._set_language_type_metadata, value)

    _script_text_metadata = { "offset" : _script_text_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def script_text(self, script:str) -> None:
        """Injects the script into the scripting tool."""
        return self._intf.invoke(ProfileScriptingTool._metadata, ProfileScriptingTool._script_text_metadata, script)

    _copy_to_clipboard_metadata = { "offset" : _copy_to_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_to_clipboard(self) -> None:
        """Copy entire scripting tool to clipboard."""
        return self._intf.invoke(ProfileScriptingTool._metadata, ProfileScriptingTool._copy_to_clipboard_metadata, )

    _paste_from_clipboard_metadata = { "offset" : _paste_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_from_clipboard(self) -> None:
        """Replace entire scripting tool with scripting tool in clipboard."""
        return self._intf.invoke(ProfileScriptingTool._metadata, ProfileScriptingTool._paste_from_clipboard_metadata, )

    _property_names[enable] = "enable"
    _property_names[segment_properties] = "segment_properties"
    _property_names[calculation_objects] = "calculation_objects"
    _property_names[parameters] = "parameters"
    _property_names[language_type] = "language_type"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileScriptingTool."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileScriptingTool)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileScriptingTool, [ProfileScriptingTool, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5081539591855218287, 5356479670344280495), ProfileScriptingTool)
agcls.AgTypeNameMap["ProfileScriptingTool"] = ProfileScriptingTool

class DifferentialCorrectorControl(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for control parameters of a differential corrector profile."""

    _num_methods = 25
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_final_value_method_offset = 4
    _get_last_update_method_offset = 5
    _get_parent_name_method_offset = 6
    _get_initial_value_method_offset = 7
    _get_perturbation_method_offset = 8
    _set_perturbation_method_offset = 9
    _get_correction_method_offset = 10
    _set_correction_method_offset = 11
    _get_tolerance_method_offset = 12
    _set_tolerance_method_offset = 13
    _get_max_step_method_offset = 14
    _set_max_step_method_offset = 15
    _get_scaling_method_method_offset = 16
    _set_scaling_method_method_offset = 17
    _get_scaling_value_method_offset = 18
    _set_scaling_value_method_offset = 19
    _get_dimension_method_offset = 20
    _get_use_custom_display_unit_method_offset = 21
    _set_use_custom_display_unit_method_offset = 22
    _get_custom_display_unit_method_offset = 23
    _set_custom_display_unit_method_offset = 24
    _get_values_method_offset = 25
    _metadata = {
        "iid_data" : (5253000958888501130, 7959737892745020576),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DifferentialCorrectorControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_name_metadata)

    _get_final_value_metadata = { "offset" : _get_final_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def final_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_final_value_metadata)

    _get_last_update_metadata = { "offset" : _get_last_update_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def last_update(self) -> typing.Any:
        """Get the amount by which the value of the independent variable changed during the last targeter run."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_last_update_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_parent_name_metadata)

    _get_initial_value_metadata = { "offset" : _get_initial_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_value(self) -> typing.Any:
        """Get the nominal value of the element selected as a parameter. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_initial_value_metadata)

    _get_perturbation_metadata = { "offset" : _get_perturbation_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def perturbation(self) -> typing.Any:
        """Get the value to be used in calculating numerical derivatives. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_perturbation_metadata)

    _set_perturbation_metadata = { "offset" : _set_perturbation_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @perturbation.setter
    def perturbation(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_perturbation_metadata, value)

    _get_correction_metadata = { "offset" : _get_correction_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def correction(self) -> typing.Any:
        """Get the amount by which the nominal value of the parameter should be corrected to achieve the selected goals. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_correction_metadata)

    _set_correction_metadata = { "offset" : _set_correction_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @correction.setter
    def correction(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_correction_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tolerance(self) -> typing.Any:
        """Get or set the smallest update to the parameter to be made before the targeter stops. Only used if the convergence criteria is set to 'Either equality constraints or last control parameter updates within tolerance'. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tolerance.setter
    def tolerance(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_tolerance_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_step(self) -> typing.Any:
        """Get or set the maximum increment to make to the value of the parameter in any one step. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_step.setter
    def max_step(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_max_step_metadata, value)

    _get_scaling_method_metadata = { "offset" : _get_scaling_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DifferentialCorrectorScalingMethod),) }
    @property
    def scaling_method(self) -> "DifferentialCorrectorScalingMethod":
        """Allow better numerical behavior if the parameters have very different magnitudes. The same scaling method is applied to all parameters."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_scaling_method_metadata)

    _set_scaling_method_metadata = { "offset" : _set_scaling_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DifferentialCorrectorScalingMethod),) }
    @scaling_method.setter
    def scaling_method(self, value:"DifferentialCorrectorScalingMethod") -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_scaling_method_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_scaling_value_metadata, value)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Dimension of the constraint."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_dimension_metadata)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._set_custom_display_unit_metadata, value)

    _get_values_metadata = { "offset" : _get_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def values(self) -> list:
        """List of values of this independent variable at each iteration, including nominal run. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorControl._metadata, DifferentialCorrectorControl._get_values_metadata)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[final_value] = "final_value"
    _property_names[last_update] = "last_update"
    _property_names[parent_name] = "parent_name"
    _property_names[initial_value] = "initial_value"
    _property_names[perturbation] = "perturbation"
    _property_names[correction] = "correction"
    _property_names[tolerance] = "tolerance"
    _property_names[max_step] = "max_step"
    _property_names[scaling_method] = "scaling_method"
    _property_names[scaling_value] = "scaling_value"
    _property_names[dimension] = "dimension"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[values] = "values"

    def __init__(self, source_object=None):
        """Construct an object of type DifferentialCorrectorControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DifferentialCorrectorControl)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DifferentialCorrectorControl, [DifferentialCorrectorControl, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5558465406678164076, 14489559354740820113), DifferentialCorrectorControl)
agcls.AgTypeNameMap["DifferentialCorrectorControl"] = DifferentialCorrectorControl

class DifferentialCorrectorResult(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for equality constraints of a differential corrector profile."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_desired_value_method_offset = 4
    _set_desired_value_method_offset = 5
    _get_current_value_method_offset = 6
    _get_parent_name_method_offset = 7
    _get_difference_method_offset = 8
    _get_tolerance_method_offset = 9
    _set_tolerance_method_offset = 10
    _get_scaling_method_method_offset = 11
    _set_scaling_method_method_offset = 12
    _get_scaling_value_method_offset = 13
    _set_scaling_value_method_offset = 14
    _get_weight_method_offset = 15
    _set_weight_method_offset = 16
    _get_dimension_method_offset = 17
    _get_use_custom_display_unit_method_offset = 18
    _set_use_custom_display_unit_method_offset = 19
    _get_custom_display_unit_method_offset = 20
    _set_custom_display_unit_method_offset = 21
    _get_values_method_offset = 22
    _metadata = {
        "iid_data" : (5087800593462724886, 6103903351099707307),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DifferentialCorrectorResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_name_metadata)

    _get_desired_value_metadata = { "offset" : _get_desired_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def desired_value(self) -> typing.Any:
        """Get or set the desired value. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_desired_value_metadata)

    _set_desired_value_metadata = { "offset" : _set_desired_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @desired_value.setter
    def desired_value(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_desired_value_metadata, value)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value achieved for this dependent variable in the last targeter run. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_current_value_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Object - the name of the segment to which the parameter belongs."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_parent_name_metadata)

    _get_difference_metadata = { "offset" : _get_difference_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def difference(self) -> typing.Any:
        """Get the difference between the current and desired value for this dependent variable. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_difference_metadata)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tolerance(self) -> typing.Any:
        """How close the targeter should come to the desired value before stopping. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tolerance.setter
    def tolerance(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_tolerance_metadata, value)

    _get_scaling_method_metadata = { "offset" : _get_scaling_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DifferentialCorrectorScalingMethod),) }
    @property
    def scaling_method(self) -> "DifferentialCorrectorScalingMethod":
        """Allow better numerical behavior if the constraints have very different magnitudes. The same scaling method is applied to all constraints."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_scaling_method_metadata)

    _set_scaling_method_metadata = { "offset" : _set_scaling_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DifferentialCorrectorScalingMethod),) }
    @scaling_method.setter
    def scaling_method(self, value:"DifferentialCorrectorScalingMethod") -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_scaling_method_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_scaling_value_metadata, value)

    _get_weight_metadata = { "offset" : _get_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def weight(self) -> float:
        """Get or set the factor by which the constraint error is to be multiplied. This is used to emphasize/de-emphasize the importance of one constraint relative to the others. Dimensionless."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_weight_metadata)

    _set_weight_metadata = { "offset" : _set_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @weight.setter
    def weight(self, value:float) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_weight_metadata, value)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Get the dimension of the values."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_dimension_metadata)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._set_custom_display_unit_metadata, value)

    _get_values_metadata = { "offset" : _get_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def values(self) -> list:
        """List of values of this dependent variable at each iteration, including nominal run. Dimension depends on context."""
        return self._intf.get_property(DifferentialCorrectorResult._metadata, DifferentialCorrectorResult._get_values_metadata)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[desired_value] = "desired_value"
    _property_names[current_value] = "current_value"
    _property_names[parent_name] = "parent_name"
    _property_names[difference] = "difference"
    _property_names[tolerance] = "tolerance"
    _property_names[scaling_method] = "scaling_method"
    _property_names[scaling_value] = "scaling_value"
    _property_names[weight] = "weight"
    _property_names[dimension] = "dimension"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[values] = "values"

    def __init__(self, source_object=None):
        """Construct an object of type DifferentialCorrectorResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DifferentialCorrectorResult)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DifferentialCorrectorResult, [DifferentialCorrectorResult, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4848528198033868470, 13072468517312703888), DifferentialCorrectorResult)
agcls.AgTypeNameMap["DifferentialCorrectorResult"] = DifferentialCorrectorResult

class DifferentialCorrectorControlCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the list of control parameters for a differential corrector profile."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _get_provide_runtime_type_info_method_offset = 5
    _metadata = {
        "iid_data" : (5331395578659733574, 4228290395270634151),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DifferentialCorrectorControlCollection)
    def __iter__(self):
        """Create an iterator for the DifferentialCorrectorControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "DifferentialCorrectorControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "DifferentialCorrectorControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(DifferentialCorrectorControlCollection._metadata, DifferentialCorrectorControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(DifferentialCorrectorControlCollection._metadata, DifferentialCorrectorControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(DifferentialCorrectorControlCollection._metadata, DifferentialCorrectorControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "DifferentialCorrectorControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(DifferentialCorrectorControlCollection._metadata, DifferentialCorrectorControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(DifferentialCorrectorControlCollection._metadata, DifferentialCorrectorControlCollection._get_provide_runtime_type_info_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type DifferentialCorrectorControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DifferentialCorrectorControlCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DifferentialCorrectorControlCollection, [DifferentialCorrectorControlCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5052038889388285920, 16755659920294581388), DifferentialCorrectorControlCollection)
agcls.AgTypeNameMap["DifferentialCorrectorControlCollection"] = DifferentialCorrectorControlCollection

class DifferentialCorrectorResultCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Differential Corrector result collection."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _get_provide_runtime_type_info_method_offset = 5
    _metadata = {
        "iid_data" : (4818834817002475399, 15340702828551915904),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DifferentialCorrectorResultCollection)
    def __iter__(self):
        """Create an iterator for the DifferentialCorrectorResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "DifferentialCorrectorResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "DifferentialCorrectorResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(DifferentialCorrectorResultCollection._metadata, DifferentialCorrectorResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(DifferentialCorrectorResultCollection._metadata, DifferentialCorrectorResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(DifferentialCorrectorResultCollection._metadata, DifferentialCorrectorResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "DifferentialCorrectorResult":
        """Return the result specified by the object/result path."""
        return self._intf.invoke(DifferentialCorrectorResultCollection._metadata, DifferentialCorrectorResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(DifferentialCorrectorResultCollection._metadata, DifferentialCorrectorResultCollection._get_provide_runtime_type_info_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type DifferentialCorrectorResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DifferentialCorrectorResultCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DifferentialCorrectorResultCollection, [DifferentialCorrectorResultCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5420089016781372257, 3020197927996230316), DifferentialCorrectorResultCollection)
agcls.AgTypeNameMap["DifferentialCorrectorResultCollection"] = DifferentialCorrectorResultCollection

class SearchPluginControl(SupportsDeleteCallback):
    """Properties of search plugin control parameters."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_control_name_method_offset = 1
    _get_current_value_method_offset = 2
    _get_parent_segment_name_method_offset = 3
    _get_initial_value_method_offset = 4
    _get_plugin_identifier_method_offset = 5
    _get_plugin_config_method_offset = 6
    _get_dimension_method_offset = 7
    _get_use_custom_display_unit_method_offset = 8
    _set_use_custom_display_unit_method_offset = 9
    _get_custom_display_unit_method_offset = 10
    _set_custom_display_unit_method_offset = 11
    _get_values_method_offset = 12
    _set_current_value_method_offset = 13
    _metadata = {
        "iid_data" : (4867399211973024127, 7320608480965167759),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SearchPluginControl)

    _get_control_name_metadata = { "offset" : _get_control_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def control_name(self) -> str:
        """Get the name of the control parameter."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_control_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the current value of the control parameter."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_current_value_metadata)

    _get_parent_segment_name_metadata = { "offset" : _get_parent_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_segment_name(self) -> str:
        """Get the parent segment of the control parameter."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_parent_segment_name_metadata)

    _get_initial_value_metadata = { "offset" : _get_initial_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_value(self) -> typing.Any:
        """Get the initial value of the control parameter. Dimension depends on context."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_initial_value_metadata)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get the plugin identifier."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_plugin_identifier_metadata)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_plugin_config_metadata)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Get the dimension of the values."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_dimension_metadata)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(SearchPluginControl._metadata, SearchPluginControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(SearchPluginControl._metadata, SearchPluginControl._set_custom_display_unit_metadata, value)

    _get_values_metadata = { "offset" : _get_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def values(self) -> list:
        """List of values of this independent variable at each iteration, including nominal run. Dimension depends on context."""
        return self._intf.get_property(SearchPluginControl._metadata, SearchPluginControl._get_values_metadata)

    _set_current_value_metadata = { "offset" : _set_current_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @current_value.setter
    def current_value(self, value:typing.Any) -> None:
        return self._intf.set_property(SearchPluginControl._metadata, SearchPluginControl._set_current_value_metadata, value)

    _property_names[control_name] = "control_name"
    _property_names[current_value] = "current_value"
    _property_names[parent_segment_name] = "parent_segment_name"
    _property_names[initial_value] = "initial_value"
    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"
    _property_names[dimension] = "dimension"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[values] = "values"

    def __init__(self, source_object=None):
        """Construct an object of type SearchPluginControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SearchPluginControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SearchPluginControl, [SearchPluginControl, ])

agcls.AgClassCatalog.add_catalog_entry((5045474660547290749, 17356533529411786427), SearchPluginControl)
agcls.AgTypeNameMap["SearchPluginControl"] = SearchPluginControl

class SearchPluginControlCollection(SupportsDeleteCallback):
    """Properties for the list of search plugin control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (4624987267695215442, 5534608355596712125),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SearchPluginControlCollection)
    def __iter__(self):
        """Create an iterator for the SearchPluginControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "SearchPluginControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "SearchPluginControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(SearchPluginControlCollection._metadata, SearchPluginControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Property that allows you to enumerate through the collection."""
        return self._intf.get_property(SearchPluginControlCollection._metadata, SearchPluginControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(SearchPluginControlCollection._metadata, SearchPluginControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "SearchPluginControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(SearchPluginControlCollection._metadata, SearchPluginControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type SearchPluginControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SearchPluginControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SearchPluginControlCollection, [SearchPluginControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4848900109341529946, 9106163264584221337), SearchPluginControlCollection)
agcls.AgTypeNameMap["SearchPluginControlCollection"] = SearchPluginControlCollection

class SearchPluginResult(SupportsDeleteCallback):
    """Properties of search plugin equality constraints."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_result_name_method_offset = 1
    _get_current_value_method_offset = 2
    _get_parent_segment_name_method_offset = 3
    _get_plugin_identifier_method_offset = 4
    _get_plugin_config_method_offset = 5
    _get_dimension_method_offset = 6
    _get_use_custom_display_unit_method_offset = 7
    _set_use_custom_display_unit_method_offset = 8
    _get_custom_display_unit_method_offset = 9
    _set_custom_display_unit_method_offset = 10
    _get_values_method_offset = 11
    _metadata = {
        "iid_data" : (4895148609240169264, 4585343154220999064),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SearchPluginResult)

    _get_result_name_metadata = { "offset" : _get_result_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def result_name(self) -> str:
        """Get the name of the equality constraint."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_result_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the current value of the result variable."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_current_value_metadata)

    _get_parent_segment_name_metadata = { "offset" : _get_parent_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_segment_name(self) -> str:
        """Get the parent segment of the result variable."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_parent_segment_name_metadata)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get the plugin identifier."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_plugin_identifier_metadata)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_plugin_config_metadata)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Get the dimension of the values."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_dimension_metadata)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(SearchPluginResult._metadata, SearchPluginResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(SearchPluginResult._metadata, SearchPluginResult._set_custom_display_unit_metadata, value)

    _get_values_metadata = { "offset" : _get_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def values(self) -> list:
        """List of values of this dependent variable at each iteration, including nominal run. Dimension depends on context."""
        return self._intf.get_property(SearchPluginResult._metadata, SearchPluginResult._get_values_metadata)

    _property_names[result_name] = "result_name"
    _property_names[current_value] = "current_value"
    _property_names[parent_segment_name] = "parent_segment_name"
    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"
    _property_names[dimension] = "dimension"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[values] = "values"

    def __init__(self, source_object=None):
        """Construct an object of type SearchPluginResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SearchPluginResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SearchPluginResult, [SearchPluginResult, ])

agcls.AgClassCatalog.add_catalog_entry((5546957583458452990, 17896374163675725444), SearchPluginResult)
agcls.AgTypeNameMap["SearchPluginResult"] = SearchPluginResult

class SearchPluginResultCollection(SupportsDeleteCallback):
    """Properties for the list of search plugin equality constraints."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (4689816242179407525, 118837404913377457),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SearchPluginResultCollection)
    def __iter__(self):
        """Create an iterator for the SearchPluginResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "SearchPluginResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "SearchPluginResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(SearchPluginResultCollection._metadata, SearchPluginResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Function to enumerate through the collection."""
        return self._intf.get_property(SearchPluginResultCollection._metadata, SearchPluginResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Size of the collection."""
        return self._intf.get_property(SearchPluginResultCollection._metadata, SearchPluginResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "SearchPluginResult":
        """Return the result specified by the object/result path."""
        return self._intf.invoke(SearchPluginResultCollection._metadata, SearchPluginResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type SearchPluginResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SearchPluginResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SearchPluginResultCollection, [SearchPluginResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4906992132230204902, 3876273479435196306), SearchPluginResultCollection)
agcls.AgTypeNameMap["SearchPluginResultCollection"] = SearchPluginResultCollection

class ProfileChangeManeuverType(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Change Maneuver Type profile."""

    _num_methods = 4
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_method_offset = 1
    _set_segment_method_offset = 2
    _get_maneuver_type_method_offset = 3
    _set_maneuver_type_method_offset = 4
    _metadata = {
        "iid_data" : (4638741168878062177, 15357931456736488104),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileChangeManeuverType)

    _get_segment_metadata = { "offset" : _get_segment_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segment(self) -> "MCSManeuver":
        """Get or set the targeted maneuver segment."""
        return self._intf.get_property(ProfileChangeManeuverType._metadata, ProfileChangeManeuverType._get_segment_metadata)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("MCSManeuver"),) }
    @segment.setter
    def segment(self, segment:"MCSManeuver") -> None:
        return self._intf.set_property(ProfileChangeManeuverType._metadata, ProfileChangeManeuverType._set_segment_metadata, segment)

    _get_maneuver_type_metadata = { "offset" : _get_maneuver_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ManeuverType),) }
    @property
    def maneuver_type(self) -> "ManeuverType":
        """Get or set the new maneuver type for the targeted segment."""
        return self._intf.get_property(ProfileChangeManeuverType._metadata, ProfileChangeManeuverType._get_maneuver_type_metadata)

    _set_maneuver_type_metadata = { "offset" : _set_maneuver_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ManeuverType),) }
    @maneuver_type.setter
    def maneuver_type(self, value:"ManeuverType") -> None:
        return self._intf.set_property(ProfileChangeManeuverType._metadata, ProfileChangeManeuverType._set_maneuver_type_metadata, value)

    _property_names[segment] = "segment"
    _property_names[maneuver_type] = "maneuver_type"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileChangeManeuverType."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileChangeManeuverType)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileChangeManeuverType, [ProfileChangeManeuverType, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5514825464600670224, 11753580946685421731), ProfileChangeManeuverType)
agcls.AgTypeNameMap["ProfileChangeManeuverType"] = ProfileChangeManeuverType

class ProfileChangeReturnSegment(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Change Return Segment profile."""

    _num_methods = 5
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_name_method_offset = 1
    _set_segment_name_method_offset = 2
    _set_segment_method_offset = 3
    _get_state_method_offset = 4
    _set_state_method_offset = 5
    _metadata = {
        "iid_data" : (4705165520827975122, 8995277470071094949),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileChangeReturnSegment)

    _get_segment_name_metadata = { "offset" : _get_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def segment_name(self) -> str:
        """Get or set the targeted return segment."""
        return self._intf.get_property(ProfileChangeReturnSegment._metadata, ProfileChangeReturnSegment._get_segment_name_metadata)

    _set_segment_name_metadata = { "offset" : _set_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @segment_name.setter
    def segment_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangeReturnSegment._metadata, ProfileChangeReturnSegment._set_segment_name_metadata, value)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("MCSReturn"),) }
    def set_segment(self, mcs_return:"MCSReturn") -> None:
        """Set the return segment to target."""
        return self._intf.invoke(ProfileChangeReturnSegment._metadata, ProfileChangeReturnSegment._set_segment_metadata, mcs_return)

    _get_state_metadata = { "offset" : _get_state_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReturnControl),) }
    @property
    def state(self) -> "ReturnControl":
        """Get or set the new state for the targeted return segment."""
        return self._intf.get_property(ProfileChangeReturnSegment._metadata, ProfileChangeReturnSegment._get_state_metadata)

    _set_state_metadata = { "offset" : _set_state_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ReturnControl),) }
    @state.setter
    def state(self, value:"ReturnControl") -> None:
        return self._intf.set_property(ProfileChangeReturnSegment._metadata, ProfileChangeReturnSegment._set_state_metadata, value)

    _property_names[segment_name] = "segment_name"
    _property_names[state] = "state"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileChangeReturnSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileChangeReturnSegment)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileChangeReturnSegment, [ProfileChangeReturnSegment, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4746376939470809221, 4289144284289568669), ProfileChangeReturnSegment)
agcls.AgTypeNameMap["ProfileChangeReturnSegment"] = ProfileChangeReturnSegment

class ProfileChangePropagator(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Change Propagator profile."""

    _num_methods = 5
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_name_method_offset = 1
    _set_segment_name_method_offset = 2
    _set_segment_method_offset = 3
    _get_propagator_name_method_offset = 4
    _set_propagator_name_method_offset = 5
    _metadata = {
        "iid_data" : (4634704878393296108, 17784937878159440318),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileChangePropagator)

    _get_segment_name_metadata = { "offset" : _get_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def segment_name(self) -> str:
        """Get or set the name of the profile."""
        return self._intf.get_property(ProfileChangePropagator._metadata, ProfileChangePropagator._get_segment_name_metadata)

    _set_segment_name_metadata = { "offset" : _set_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @segment_name.setter
    def segment_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangePropagator._metadata, ProfileChangePropagator._set_segment_name_metadata, value)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IMCSSegment"),) }
    def set_segment(self, mcs_segment:"IMCSSegment") -> None:
        """Set the targeted segment."""
        return self._intf.invoke(ProfileChangePropagator._metadata, ProfileChangePropagator._set_segment_metadata, mcs_segment)

    _get_propagator_name_metadata = { "offset" : _get_propagator_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propagator_name(self) -> str:
        """Get or set the new propagator's name."""
        return self._intf.get_property(ProfileChangePropagator._metadata, ProfileChangePropagator._get_propagator_name_metadata)

    _set_propagator_name_metadata = { "offset" : _set_propagator_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @propagator_name.setter
    def propagator_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangePropagator._metadata, ProfileChangePropagator._set_propagator_name_metadata, value)

    _property_names[segment_name] = "segment_name"
    _property_names[propagator_name] = "propagator_name"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileChangePropagator."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileChangePropagator)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileChangePropagator, [ProfileChangePropagator, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4917428364571480839, 14790385948966539179), ProfileChangePropagator)
agcls.AgTypeNameMap["ProfileChangePropagator"] = ProfileChangePropagator

class ProfileChangeStopSegment(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Change Stop Segment profile."""

    _num_methods = 5
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_name_method_offset = 1
    _set_segment_name_method_offset = 2
    _set_segment_method_offset = 3
    _get_state_method_offset = 4
    _set_state_method_offset = 5
    _metadata = {
        "iid_data" : (4939758405760454184, 7478107008343462300),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileChangeStopSegment)

    _get_segment_name_metadata = { "offset" : _get_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def segment_name(self) -> str:
        """Get or set the targeted stop segment."""
        return self._intf.get_property(ProfileChangeStopSegment._metadata, ProfileChangeStopSegment._get_segment_name_metadata)

    _set_segment_name_metadata = { "offset" : _set_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @segment_name.setter
    def segment_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangeStopSegment._metadata, ProfileChangeStopSegment._set_segment_name_metadata, value)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("MCSStop"),) }
    def set_segment(self, mcs_stop:"MCSStop") -> None:
        """Set the stop segment to target."""
        return self._intf.invoke(ProfileChangeStopSegment._metadata, ProfileChangeStopSegment._set_segment_metadata, mcs_stop)

    _get_state_metadata = { "offset" : _get_state_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(StateType),) }
    @property
    def state(self) -> "StateType":
        """Get or set the new state of the targeted stop segment."""
        return self._intf.get_property(ProfileChangeStopSegment._metadata, ProfileChangeStopSegment._get_state_metadata)

    _set_state_metadata = { "offset" : _set_state_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(StateType),) }
    @state.setter
    def state(self, value:"StateType") -> None:
        return self._intf.set_property(ProfileChangeStopSegment._metadata, ProfileChangeStopSegment._set_state_metadata, value)

    _property_names[segment_name] = "segment_name"
    _property_names[state] = "state"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileChangeStopSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileChangeStopSegment)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileChangeStopSegment, [ProfileChangeStopSegment, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5176652920498491223, 12779532205614345663), ProfileChangeStopSegment)
agcls.AgTypeNameMap["ProfileChangeStopSegment"] = ProfileChangeStopSegment

class ProfileChangeStoppingConditionState(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Change Stopping Condition State profile."""

    _num_methods = 8
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_name_method_offset = 1
    _set_segment_name_method_offset = 2
    _set_segment_method_offset = 3
    _get_state_method_offset = 4
    _set_state_method_offset = 5
    _set_trigger_method_offset = 6
    _get_trigger_name_method_offset = 7
    _set_trigger_name_method_offset = 8
    _metadata = {
        "iid_data" : (5430643143655333764, 9065193238726384518),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileChangeStoppingConditionState)

    _get_segment_name_metadata = { "offset" : _get_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def segment_name(self) -> str:
        """Get or set the segment that contains the targeted stopping condition."""
        return self._intf.get_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._get_segment_name_metadata)

    _set_segment_name_metadata = { "offset" : _set_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @segment_name.setter
    def segment_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._set_segment_name_metadata, value)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IMCSSegment"),) }
    def set_segment(self, mcs_segment:"IMCSSegment") -> None:
        """Set the targeted segment."""
        return self._intf.invoke(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._set_segment_metadata, mcs_segment)

    _get_state_metadata = { "offset" : _get_state_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(StateType),) }
    @property
    def state(self) -> "StateType":
        """Get or set the new state of the targeted stopping condition."""
        return self._intf.get_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._get_state_metadata)

    _set_state_metadata = { "offset" : _set_state_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(StateType),) }
    @state.setter
    def state(self, value:"StateType") -> None:
        return self._intf.set_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._set_state_metadata, value)

    _set_trigger_metadata = { "offset" : _set_trigger_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("StoppingCondition"),) }
    def set_trigger(self, stopping_condition:"StoppingCondition") -> None:
        """Set the targeted stopping condition."""
        return self._intf.invoke(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._set_trigger_metadata, stopping_condition)

    _get_trigger_name_metadata = { "offset" : _get_trigger_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def trigger_name(self) -> str:
        """Get or set the name of the targeted stopping condition."""
        return self._intf.get_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._get_trigger_name_metadata)

    _set_trigger_name_metadata = { "offset" : _set_trigger_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @trigger_name.setter
    def trigger_name(self, value:str) -> None:
        return self._intf.set_property(ProfileChangeStoppingConditionState._metadata, ProfileChangeStoppingConditionState._set_trigger_name_metadata, value)

    _property_names[segment_name] = "segment_name"
    _property_names[state] = "state"
    _property_names[trigger_name] = "trigger_name"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileChangeStoppingConditionState."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileChangeStoppingConditionState)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileChangeStoppingConditionState, [ProfileChangeStoppingConditionState, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4678353966876850557, 14685284640460450435), ProfileChangeStoppingConditionState)
agcls.AgTypeNameMap["ProfileChangeStoppingConditionState"] = ProfileChangeStoppingConditionState

class ProfileSeedFiniteManeuver(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Seed Finite Maneuver segment."""

    _num_methods = 5
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_segment_name_method_offset = 1
    _set_segment_name_method_offset = 2
    _set_segment_method_offset = 3
    _get_leave_all_active_stopping_conditions_active_method_offset = 4
    _set_leave_all_active_stopping_conditions_active_method_offset = 5
    _metadata = {
        "iid_data" : (5161634194327496149, 14603357244715454085),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileSeedFiniteManeuver)

    _get_segment_name_metadata = { "offset" : _get_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def segment_name(self) -> str:
        """Get or set the targeted maneuver segment."""
        return self._intf.get_property(ProfileSeedFiniteManeuver._metadata, ProfileSeedFiniteManeuver._get_segment_name_metadata)

    _set_segment_name_metadata = { "offset" : _set_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @segment_name.setter
    def segment_name(self, value:str) -> None:
        return self._intf.set_property(ProfileSeedFiniteManeuver._metadata, ProfileSeedFiniteManeuver._set_segment_name_metadata, value)

    _set_segment_metadata = { "offset" : _set_segment_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("MCSManeuver"),) }
    def set_segment(self, mcs_maneuver:"MCSManeuver") -> None:
        """Set the maneuver segment to target."""
        return self._intf.invoke(ProfileSeedFiniteManeuver._metadata, ProfileSeedFiniteManeuver._set_segment_metadata, mcs_maneuver)

    _get_leave_all_active_stopping_conditions_active_metadata = { "offset" : _get_leave_all_active_stopping_conditions_active_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def leave_all_active_stopping_conditions_active(self) -> bool:
        """If true, all active stopping conditions on the seeded maneuver will remain active during run."""
        return self._intf.get_property(ProfileSeedFiniteManeuver._metadata, ProfileSeedFiniteManeuver._get_leave_all_active_stopping_conditions_active_metadata)

    _set_leave_all_active_stopping_conditions_active_metadata = { "offset" : _set_leave_all_active_stopping_conditions_active_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @leave_all_active_stopping_conditions_active.setter
    def leave_all_active_stopping_conditions_active(self, value:bool) -> None:
        return self._intf.set_property(ProfileSeedFiniteManeuver._metadata, ProfileSeedFiniteManeuver._set_leave_all_active_stopping_conditions_active_metadata, value)

    _property_names[segment_name] = "segment_name"
    _property_names[leave_all_active_stopping_conditions_active] = "leave_all_active_stopping_conditions_active"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileSeedFiniteManeuver."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileSeedFiniteManeuver)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileSeedFiniteManeuver, [ProfileSeedFiniteManeuver, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4619183164175431290, 12957669796538914955), ProfileSeedFiniteManeuver)
agcls.AgTypeNameMap["ProfileSeedFiniteManeuver"] = ProfileSeedFiniteManeuver

class ProfileRunOnce(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Run Once profile."""

    _num_methods = 0
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _metadata = {
        "iid_data" : (5362986155356147363, 15814818936516716949),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileRunOnce)


    def __init__(self, source_object=None):
        """Construct an object of type ProfileRunOnce."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileRunOnce)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileRunOnce, [ProfileRunOnce, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5722064001165018176, 12997517095273249469), ProfileRunOnce)
agcls.AgTypeNameMap["ProfileRunOnce"] = ProfileRunOnce

class BPlaneCollection(SupportsDeleteCallback):
    """Properties for the collection of B-Planes."""

    _num_methods = 6
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _remove_method_offset = 2
    _remove_all_method_offset = 3
    _item_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _metadata = {
        "iid_data" : (5594941962752983119, 13562937374643146671),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BPlaneCollection)
    def __iter__(self):
        """Create an iterator for the BPlaneCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> str:
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def add(self, plane_name:str) -> None:
        """Add a BPlane."""
        return self._intf.invoke(BPlaneCollection._metadata, BPlaneCollection._add_metadata, plane_name)

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove(self, plane_name:str) -> None:
        """Remove a BPlane."""
        return self._intf.invoke(BPlaneCollection._metadata, BPlaneCollection._remove_metadata, plane_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all BPlanes."""
        return self._intf.invoke(BPlaneCollection._metadata, BPlaneCollection._remove_all_metadata, )

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.LongArg, agmarshall.BStrArg,) }
    def item(self, index:int) -> str:
        """Allow you to iterate through the collection."""
        return self._intf.invoke(BPlaneCollection._metadata, BPlaneCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(BPlaneCollection._metadata, BPlaneCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Get the number of active BPlanes."""
        return self._intf.get_property(BPlaneCollection._metadata, BPlaneCollection._get_count_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type BPlaneCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BPlaneCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BPlaneCollection, [BPlaneCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5110455434975895853, 10166370749291811978), BPlaneCollection)
agcls.AgTypeNameMap["BPlaneCollection"] = BPlaneCollection

class StateCalcDamageFlux(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcDamageFlux."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5064599181893483132, 838052118368786821),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDamageFlux)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDamageFlux."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDamageFlux)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDamageFlux, [StateCalcDamageFlux, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5061318997549054970, 5706412726880589720), StateCalcDamageFlux)
agcls.AgTypeNameMap["StateCalcDamageFlux"] = StateCalcDamageFlux

class StateCalcDamageMassFlux(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcDamageMassFlux."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5323133528960076198, 12570579641122910654),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDamageMassFlux)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDamageMassFlux."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDamageMassFlux)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDamageMassFlux, [StateCalcDamageMassFlux, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4973428904588242653, 6958212153847005885), StateCalcDamageMassFlux)
agcls.AgTypeNameMap["StateCalcDamageMassFlux"] = StateCalcDamageMassFlux

class StateCalcMagneticFieldDipoleL(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcMagFieldDipoleL."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5572993639986105434, 2150862437823850410),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMagneticFieldDipoleL)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMagneticFieldDipoleL."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMagneticFieldDipoleL)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMagneticFieldDipoleL, [StateCalcMagneticFieldDipoleL, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4679876560310607257, 8310578291428709278), StateCalcMagneticFieldDipoleL)
agcls.AgTypeNameMap["StateCalcMagneticFieldDipoleL"] = StateCalcMagneticFieldDipoleL

class StateCalcSEETMagneticFieldLineSeparationAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a SEETMagFieldFieldLineSepAngle calculation object."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_object_method_offset = 1
    _metadata = {
        "iid_data" : (5335771638573946346, 7564082294565021117),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSEETMagneticFieldLineSeparationAngle)

    _get_target_object_metadata = { "offset" : _get_target_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def target_object(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcSEETMagneticFieldLineSeparationAngle._metadata, StateCalcSEETMagneticFieldLineSeparationAngle._get_target_object_metadata)

    _property_names[target_object] = "target_object"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSEETMagneticFieldLineSeparationAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSEETMagneticFieldLineSeparationAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSEETMagneticFieldLineSeparationAngle, [StateCalcSEETMagneticFieldLineSeparationAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5587815812935971298, 7525019620982063505), StateCalcSEETMagneticFieldLineSeparationAngle)
agcls.AgTypeNameMap["StateCalcSEETMagneticFieldLineSeparationAngle"] = StateCalcSEETMagneticFieldLineSeparationAngle

class StateCalcImpactFlux(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcImpactFlux."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4712475622720863446, 9874820785248486066),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcImpactFlux)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcImpactFlux."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcImpactFlux)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcImpactFlux, [StateCalcImpactFlux, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5205176986868350023, 2621073616466898844), StateCalcImpactFlux)
agcls.AgTypeNameMap["StateCalcImpactFlux"] = StateCalcImpactFlux

class StateCalcImpactMassFlux(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcImpactMassFlux."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5663867202832921241, 12848046706352279460),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcImpactMassFlux)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcImpactMassFlux."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcImpactMassFlux)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcImpactMassFlux, [StateCalcImpactMassFlux, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5270447181510537100, 9273433778213163966), StateCalcImpactMassFlux)
agcls.AgTypeNameMap["StateCalcImpactMassFlux"] = StateCalcImpactMassFlux

class StateCalcSEETSAAFlux(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcSEETSAAFlux."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5229848331502696195, 11640390802336049814),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSEETSAAFlux)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSEETSAAFlux."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSEETSAAFlux)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSEETSAAFlux, [StateCalcSEETSAAFlux, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5390130523806265182, 8748824487015767454), StateCalcSEETSAAFlux)
agcls.AgTypeNameMap["StateCalcSEETSAAFlux"] = StateCalcSEETSAAFlux

class StateCalcSEETVehTemp(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AgAsStateCalcSEETVehTemp."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5710340041284306171, 10643006267837267871),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSEETVehTemp)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSEETVehTemp."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSEETVehTemp)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSEETVehTemp, [StateCalcSEETVehTemp, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5450830750262536790, 298824803349435582), StateCalcSEETVehTemp)
agcls.AgTypeNameMap["StateCalcSEETVehTemp"] = StateCalcSEETVehTemp

class StateCalcEpoch(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Epoch calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4735976942903942727, 11382373395637864086),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEpoch)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEpoch."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEpoch)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEpoch, [StateCalcEpoch, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5546769491034375944, 206659031291144346), StateCalcEpoch)
agcls.AgTypeNameMap["StateCalcEpoch"] = StateCalcEpoch

class StateCalcJacobiConstant(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Jacobi Constant calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5313931721597877856, 6320025579692878468),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcJacobiConstant)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcJacobiConstant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcJacobiConstant)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcJacobiConstant, [StateCalcJacobiConstant, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4926408186651605609, 4266894203843328418), StateCalcJacobiConstant)
agcls.AgTypeNameMap["StateCalcJacobiConstant"] = StateCalcJacobiConstant

class StateCalcJacobiOsculating(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an osculating Jacobi integral calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_secondary_name_method_offset = 3
    _set_secondary_name_method_offset = 4
    _metadata = {
        "iid_data" : (4962445305111709194, 10572901812271851444),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcJacobiOsculating)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the primary central body of the three-body system."""
        return self._intf.get_property(StateCalcJacobiOsculating._metadata, StateCalcJacobiOsculating._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcJacobiOsculating._metadata, StateCalcJacobiOsculating._set_central_body_name_metadata, value)

    _get_secondary_name_metadata = { "offset" : _get_secondary_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def secondary_name(self) -> str:
        """Get or set the secondary central body of the three-body system."""
        return self._intf.get_property(StateCalcJacobiOsculating._metadata, StateCalcJacobiOsculating._get_secondary_name_metadata)

    _set_secondary_name_metadata = { "offset" : _set_secondary_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @secondary_name.setter
    def secondary_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcJacobiOsculating._metadata, StateCalcJacobiOsculating._set_secondary_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[secondary_name] = "secondary_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcJacobiOsculating."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcJacobiOsculating)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcJacobiOsculating, [StateCalcJacobiOsculating, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4893148544095721651, 9245737750026533311), StateCalcJacobiOsculating)
agcls.AgTypeNameMap["StateCalcJacobiOsculating"] = StateCalcJacobiOsculating

class StateCalcCartesianElem(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Cartesian Element calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5592104075436038276, 13656611350088774319),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCartesianElem)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcCartesianElem._metadata, StateCalcCartesianElem._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCartesianElem._metadata, StateCalcCartesianElem._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCartesianElem."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCartesianElem)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCartesianElem, [StateCalcCartesianElem, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5671576764808850599, 13911282508128967061), StateCalcCartesianElem)
agcls.AgTypeNameMap["StateCalcCartesianElem"] = StateCalcCartesianElem

class StateCalcCartSTMElem(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Cartesian STM Element calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_final_state_component_method_offset = 3
    _set_final_state_component_method_offset = 4
    _get_initial_state_component_method_offset = 5
    _set_initial_state_component_method_offset = 6
    _metadata = {
        "iid_data" : (4663303186423105219, 10757831706775060869),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCartSTMElem)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._set_coord_system_name_metadata, value)

    _get_final_state_component_metadata = { "offset" : _get_final_state_component_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @property
    def final_state_component(self) -> "STMPerturbationVariables":
        """Get or set the final variation variable."""
        return self._intf.get_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._get_final_state_component_metadata)

    _set_final_state_component_metadata = { "offset" : _set_final_state_component_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @final_state_component.setter
    def final_state_component(self, value:"STMPerturbationVariables") -> None:
        return self._intf.set_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._set_final_state_component_metadata, value)

    _get_initial_state_component_metadata = { "offset" : _get_initial_state_component_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @property
    def initial_state_component(self) -> "STMPerturbationVariables":
        """Get or set the initial variation variable."""
        return self._intf.get_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._get_initial_state_component_metadata)

    _set_initial_state_component_metadata = { "offset" : _set_initial_state_component_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @initial_state_component.setter
    def initial_state_component(self, value:"STMPerturbationVariables") -> None:
        return self._intf.set_property(StateCalcCartSTMElem._metadata, StateCalcCartSTMElem._set_initial_state_component_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[final_state_component] = "final_state_component"
    _property_names[initial_state_component] = "initial_state_component"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCartSTMElem."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCartSTMElem)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCartSTMElem, [StateCalcCartSTMElem, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4764427105086404315, 18352981306806488972), StateCalcCartSTMElem)
agcls.AgTypeNameMap["StateCalcCartSTMElem"] = StateCalcCartSTMElem

class StateCalcSTMEigenval(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an STM Eigenvalue calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_eigenvalue_number_method_offset = 3
    _set_eigenvalue_number_method_offset = 4
    _get_eigenvalue_complex_part_method_offset = 5
    _set_eigenvalue_complex_part_method_offset = 6
    _metadata = {
        "iid_data" : (4683699417864441378, 8882850736444958850),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSTMEigenval)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._set_coord_system_name_metadata, value)

    _get_eigenvalue_number_metadata = { "offset" : _get_eigenvalue_number_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STMEigenNumber),) }
    @property
    def eigenvalue_number(self) -> "STMEigenNumber":
        """Get or set the number identifying one of the six Eigenvalues."""
        return self._intf.get_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._get_eigenvalue_number_metadata)

    _set_eigenvalue_number_metadata = { "offset" : _set_eigenvalue_number_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STMEigenNumber),) }
    @eigenvalue_number.setter
    def eigenvalue_number(self, value:"STMEigenNumber") -> None:
        return self._intf.set_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._set_eigenvalue_number_metadata, value)

    _get_eigenvalue_complex_part_metadata = { "offset" : _get_eigenvalue_complex_part_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ComplexNumber),) }
    @property
    def eigenvalue_complex_part(self) -> "ComplexNumber":
        """Whether this value represents the real or imaginary part of the Eigenvalue."""
        return self._intf.get_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._get_eigenvalue_complex_part_metadata)

    _set_eigenvalue_complex_part_metadata = { "offset" : _set_eigenvalue_complex_part_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ComplexNumber),) }
    @eigenvalue_complex_part.setter
    def eigenvalue_complex_part(self, value:"ComplexNumber") -> None:
        return self._intf.set_property(StateCalcSTMEigenval._metadata, StateCalcSTMEigenval._set_eigenvalue_complex_part_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[eigenvalue_number] = "eigenvalue_number"
    _property_names[eigenvalue_complex_part] = "eigenvalue_complex_part"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSTMEigenval."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSTMEigenval)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSTMEigenval, [StateCalcSTMEigenval, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4668678151179349103, 6834144943639096487), StateCalcSTMEigenval)
agcls.AgTypeNameMap["StateCalcSTMEigenval"] = StateCalcSTMEigenval

class StateCalcSTMEigenvecElem(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an STM Eigenvector element calculation object."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_eigenvector_number_method_offset = 3
    _set_eigenvector_number_method_offset = 4
    _get_state_variable_method_offset = 5
    _set_state_variable_method_offset = 6
    _get_eigenvector_complex_part_method_offset = 7
    _set_eigenvector_complex_part_method_offset = 8
    _metadata = {
        "iid_data" : (5656549373487126346, 16982121463062240904),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSTMEigenvecElem)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._set_coord_system_name_metadata, value)

    _get_eigenvector_number_metadata = { "offset" : _get_eigenvector_number_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STMEigenNumber),) }
    @property
    def eigenvector_number(self) -> "STMEigenNumber":
        """Get or set the number identifying one of the six Eigenvectors."""
        return self._intf.get_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._get_eigenvector_number_metadata)

    _set_eigenvector_number_metadata = { "offset" : _set_eigenvector_number_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STMEigenNumber),) }
    @eigenvector_number.setter
    def eigenvector_number(self, value:"STMEigenNumber") -> None:
        return self._intf.set_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._set_eigenvector_number_metadata, value)

    _get_state_variable_metadata = { "offset" : _get_state_variable_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @property
    def state_variable(self) -> "STMPerturbationVariables":
        """Get or set the variable identifying the component within an Eigenvector."""
        return self._intf.get_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._get_state_variable_metadata)

    _set_state_variable_metadata = { "offset" : _set_state_variable_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STMPerturbationVariables),) }
    @state_variable.setter
    def state_variable(self, value:"STMPerturbationVariables") -> None:
        return self._intf.set_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._set_state_variable_metadata, value)

    _get_eigenvector_complex_part_metadata = { "offset" : _get_eigenvector_complex_part_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ComplexNumber),) }
    @property
    def eigenvector_complex_part(self) -> "ComplexNumber":
        """Whether this value represents the real or imaginary part of an Eigenvector element."""
        return self._intf.get_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._get_eigenvector_complex_part_metadata)

    _set_eigenvector_complex_part_metadata = { "offset" : _set_eigenvector_complex_part_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ComplexNumber),) }
    @eigenvector_complex_part.setter
    def eigenvector_complex_part(self, value:"ComplexNumber") -> None:
        return self._intf.set_property(StateCalcSTMEigenvecElem._metadata, StateCalcSTMEigenvecElem._set_eigenvector_complex_part_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[eigenvector_number] = "eigenvector_number"
    _property_names[state_variable] = "state_variable"
    _property_names[eigenvector_complex_part] = "eigenvector_complex_part"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSTMEigenvecElem."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSTMEigenvecElem)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSTMEigenvecElem, [StateCalcSTMEigenvecElem, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5648792996863224538, 14390084934938091964), StateCalcSTMEigenvecElem)
agcls.AgTypeNameMap["StateCalcSTMEigenvecElem"] = StateCalcSTMEigenvecElem

class StateCalcEnvironment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Environment calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_atmosphere_model_name_method_offset = 3
    _set_atmosphere_model_name_method_offset = 4
    _metadata = {
        "iid_data" : (4823976028697900760, 927912681356112823),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEnvironment)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEnvironment._metadata, StateCalcEnvironment._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEnvironment._metadata, StateCalcEnvironment._set_central_body_name_metadata, value)

    _get_atmosphere_model_name_metadata = { "offset" : _get_atmosphere_model_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_model_name(self) -> str:
        """Get or set the atmospheric density model of the component."""
        return self._intf.get_property(StateCalcEnvironment._metadata, StateCalcEnvironment._get_atmosphere_model_name_metadata)

    _set_atmosphere_model_name_metadata = { "offset" : _set_atmosphere_model_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_model_name.setter
    def atmosphere_model_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEnvironment._metadata, StateCalcEnvironment._set_atmosphere_model_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[atmosphere_model_name] = "atmosphere_model_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEnvironment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEnvironment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEnvironment, [StateCalcEnvironment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5228943156068851180, 17757122866649733292), StateCalcEnvironment)
agcls.AgTypeNameMap["StateCalcEnvironment"] = StateCalcEnvironment

class StateCalcOrbitDelaunayG(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AsStateCalcOrbitDelaunayG."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4629954694119662350, 8751096521941454219),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitDelaunayG)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Central Body used for calculation."""
        return self._intf.get_property(StateCalcOrbitDelaunayG._metadata, StateCalcOrbitDelaunayG._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        """Central Body used for calculation."""
        return self._intf.set_property(StateCalcOrbitDelaunayG._metadata, StateCalcOrbitDelaunayG._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @property
    def element_type(self) -> "ElementType":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcOrbitDelaunayG._metadata, StateCalcOrbitDelaunayG._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @element_type.setter
    def element_type(self, value:"ElementType") -> None:
        """Choice of osculating or mean elements."""
        return self._intf.set_property(StateCalcOrbitDelaunayG._metadata, StateCalcOrbitDelaunayG._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitDelaunayG."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitDelaunayG)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitDelaunayG, [StateCalcOrbitDelaunayG, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4685955006802271629, 16763781113943652765), StateCalcOrbitDelaunayG)
agcls.AgTypeNameMap["StateCalcOrbitDelaunayG"] = StateCalcOrbitDelaunayG

class StateCalcOrbitDelaunayH(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AsStateCalcOrbitDelaunayH."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4828188022700843748, 13086359271346066049),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitDelaunayH)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Central Body used for calculation."""
        return self._intf.get_property(StateCalcOrbitDelaunayH._metadata, StateCalcOrbitDelaunayH._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        """Central Body used for calculation."""
        return self._intf.set_property(StateCalcOrbitDelaunayH._metadata, StateCalcOrbitDelaunayH._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @property
    def element_type(self) -> "ElementType":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcOrbitDelaunayH._metadata, StateCalcOrbitDelaunayH._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @element_type.setter
    def element_type(self, value:"ElementType") -> None:
        """Choice of osculating or mean elements."""
        return self._intf.set_property(StateCalcOrbitDelaunayH._metadata, StateCalcOrbitDelaunayH._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitDelaunayH."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitDelaunayH)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitDelaunayH, [StateCalcOrbitDelaunayH, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4695981083676433439, 17340207238014231457), StateCalcOrbitDelaunayH)
agcls.AgTypeNameMap["StateCalcOrbitDelaunayH"] = StateCalcOrbitDelaunayH

class StateCalcOrbitDelaunayL(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AsStateCalcOrbitDelaunayL."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5043781925077325770, 5014519046419148467),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitDelaunayL)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Central Body used for calculation."""
        return self._intf.get_property(StateCalcOrbitDelaunayL._metadata, StateCalcOrbitDelaunayL._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        """Central Body used for calculation."""
        return self._intf.set_property(StateCalcOrbitDelaunayL._metadata, StateCalcOrbitDelaunayL._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @property
    def element_type(self) -> "ElementType":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcOrbitDelaunayL._metadata, StateCalcOrbitDelaunayL._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @element_type.setter
    def element_type(self, value:"ElementType") -> None:
        """Choice of osculating or mean elements."""
        return self._intf.set_property(StateCalcOrbitDelaunayL._metadata, StateCalcOrbitDelaunayL._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitDelaunayL."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitDelaunayL)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitDelaunayL, [StateCalcOrbitDelaunayL, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5342683362640941046, 3476677555251016876), StateCalcOrbitDelaunayL)
agcls.AgTypeNameMap["StateCalcOrbitDelaunayL"] = StateCalcOrbitDelaunayL

class StateCalcOrbitSemilatusRectum(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for AsStateCalcOrbitSemiLatusRectum."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4727248633391047542, 9754913951693591686),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitSemilatusRectum)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Central Body used for calculation."""
        return self._intf.get_property(StateCalcOrbitSemilatusRectum._metadata, StateCalcOrbitSemilatusRectum._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        """Central Body used for calculation."""
        return self._intf.set_property(StateCalcOrbitSemilatusRectum._metadata, StateCalcOrbitSemilatusRectum._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @property
    def element_type(self) -> "ElementType":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcOrbitSemilatusRectum._metadata, StateCalcOrbitSemilatusRectum._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ElementType),) }
    @element_type.setter
    def element_type(self, value:"ElementType") -> None:
        """Choice of osculating or mean elements."""
        return self._intf.set_property(StateCalcOrbitSemilatusRectum._metadata, StateCalcOrbitSemilatusRectum._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitSemilatusRectum."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitSemilatusRectum)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitSemilatusRectum, [StateCalcOrbitSemilatusRectum, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5167808672944813185, 3570909631788799361), StateCalcOrbitSemilatusRectum)
agcls.AgTypeNameMap["StateCalcOrbitSemilatusRectum"] = StateCalcOrbitSemilatusRectum

class StateCalcEquinoctialElem(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Equinoctial Element calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4687629718843532572, 7588634511906910083),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEquinoctialElem)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcEquinoctialElem._metadata, StateCalcEquinoctialElem._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEquinoctialElem._metadata, StateCalcEquinoctialElem._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcEquinoctialElem._metadata, StateCalcEquinoctialElem._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcEquinoctialElem._metadata, StateCalcEquinoctialElem._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEquinoctialElem."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEquinoctialElem)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEquinoctialElem, [StateCalcEquinoctialElem, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5398742840011437893, 227870584704275350), StateCalcEquinoctialElem)
agcls.AgTypeNameMap["StateCalcEquinoctialElem"] = StateCalcEquinoctialElem

class StateCalcCloseApproachBearing(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CloseApproachBearing calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5677747572906750359, 17530109461809240255),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachBearing)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachBearing._metadata, StateCalcCloseApproachBearing._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachBearing._metadata, StateCalcCloseApproachBearing._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachBearing._metadata, StateCalcCloseApproachBearing._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachBearing._metadata, StateCalcCloseApproachBearing._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachBearing._metadata, StateCalcCloseApproachBearing._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachBearing."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachBearing)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachBearing, [StateCalcCloseApproachBearing, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5673849013798805503, 12351132588816539044), StateCalcCloseApproachBearing)
agcls.AgTypeNameMap["StateCalcCloseApproachBearing"] = StateCalcCloseApproachBearing

class StateCalcCloseApproachMagnitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CloseApproachMagnitude calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5096713311629407959, 7012635135066643106),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachMagnitude)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachMagnitude._metadata, StateCalcCloseApproachMagnitude._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachMagnitude._metadata, StateCalcCloseApproachMagnitude._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachMagnitude._metadata, StateCalcCloseApproachMagnitude._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachMagnitude._metadata, StateCalcCloseApproachMagnitude._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachMagnitude._metadata, StateCalcCloseApproachMagnitude._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachMagnitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachMagnitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachMagnitude, [StateCalcCloseApproachMagnitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4806523612511477556, 15183989687545663893), StateCalcCloseApproachMagnitude)
agcls.AgTypeNameMap["StateCalcCloseApproachMagnitude"] = StateCalcCloseApproachMagnitude

class StateCalcCloseApproachTheta(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CloseApproachTheta calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5543110129027246069, 1448557117509499520),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachTheta)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachTheta._metadata, StateCalcCloseApproachTheta._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachTheta._metadata, StateCalcCloseApproachTheta._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachTheta._metadata, StateCalcCloseApproachTheta._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachTheta._metadata, StateCalcCloseApproachTheta._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachTheta._metadata, StateCalcCloseApproachTheta._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachTheta."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachTheta)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachTheta, [StateCalcCloseApproachTheta, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4909532356409140730, 18100928748041625783), StateCalcCloseApproachTheta)
agcls.AgTypeNameMap["StateCalcCloseApproachTheta"] = StateCalcCloseApproachTheta

class StateCalcCloseApproachX(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CloseApproachX calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5703412290879946724, 17147536145516108952),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachX)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachX._metadata, StateCalcCloseApproachX._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachX._metadata, StateCalcCloseApproachX._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachX._metadata, StateCalcCloseApproachX._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachX._metadata, StateCalcCloseApproachX._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachX._metadata, StateCalcCloseApproachX._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachX."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachX)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachX, [StateCalcCloseApproachX, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5353198940786789077, 95422187460363692), StateCalcCloseApproachX)
agcls.AgTypeNameMap["StateCalcCloseApproachX"] = StateCalcCloseApproachX

class StateCalcCloseApproachY(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CloseApproachY calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5341388972549716688, 7926797166447798699),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachY)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachY._metadata, StateCalcCloseApproachY._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachY._metadata, StateCalcCloseApproachY._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachY._metadata, StateCalcCloseApproachY._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachY._metadata, StateCalcCloseApproachY._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachY._metadata, StateCalcCloseApproachY._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachY."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachY)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachY, [StateCalcCloseApproachY, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5349645181006472612, 9759450691620504739), StateCalcCloseApproachY)
agcls.AgTypeNameMap["StateCalcCloseApproachY"] = StateCalcCloseApproachY

class StateCalcCloseApproachCosBearing(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a CosineOfCloseApproachBearing calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (5319004906284090405, 2840766454167777156),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCloseApproachCosBearing)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCloseApproachCosBearing._metadata, StateCalcCloseApproachCosBearing._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCloseApproachCosBearing._metadata, StateCalcCloseApproachCosBearing._set_central_body_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCloseApproachCosBearing._metadata, StateCalcCloseApproachCosBearing._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCloseApproachCosBearing._metadata, StateCalcCloseApproachCosBearing._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCloseApproachCosBearing._metadata, StateCalcCloseApproachCosBearing._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCloseApproachCosBearing."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCloseApproachCosBearing)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCloseApproachCosBearing, [StateCalcCloseApproachCosBearing, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5505780054597041956, 16274471926901001118), StateCalcCloseApproachCosBearing)
agcls.AgTypeNameMap["StateCalcCloseApproachCosBearing"] = StateCalcCloseApproachCosBearing

class StateCalcRelativeGroundTrackError(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RelGroundTrackError calculation object."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_direction_method_offset = 3
    _set_direction_method_offset = 4
    _get_signed_method_offset = 5
    _set_signed_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _metadata = {
        "iid_data" : (5429647627719116828, 4957543161310045354),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativeGroundTrackError)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._set_central_body_name_metadata, value)

    _get_direction_metadata = { "offset" : _get_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectDirection),) }
    @property
    def direction(self) -> "CalculationObjectDirection":
        """Get or set the direction to search for the desired value."""
        return self._intf.get_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._get_direction_metadata)

    _set_direction_metadata = { "offset" : _set_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectDirection),) }
    @direction.setter
    def direction(self, value:"CalculationObjectDirection") -> None:
        return self._intf.set_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._set_direction_metadata, value)

    _get_signed_metadata = { "offset" : _get_signed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def signed(self) -> bool:
        """True if signed based on RxV."""
        return self._intf.get_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._get_signed_metadata)

    _set_signed_metadata = { "offset" : _set_signed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @signed.setter
    def signed(self, value:bool) -> None:
        return self._intf.set_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._set_signed_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativeGroundTrackError._metadata, StateCalcRelativeGroundTrackError._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[direction] = "direction"
    _property_names[signed] = "signed"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativeGroundTrackError."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativeGroundTrackError)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativeGroundTrackError, [StateCalcRelativeGroundTrackError, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4720669564841700935, 1002250866014191547), StateCalcRelativeGroundTrackError)
agcls.AgTypeNameMap["StateCalcRelativeGroundTrackError"] = StateCalcRelativeGroundTrackError

class StateCalcRelativeAtAOLMaster(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RelativeAtAOL calculation object."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_calculation_object_name_method_offset = 3
    _set_calculation_object_name_method_offset = 4
    _get_direction_method_offset = 5
    _set_direction_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _metadata = {
        "iid_data" : (5046657111336222496, 5887915217920829318),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativeAtAOLMaster)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._set_central_body_name_metadata, value)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object of interest."""
        return self._intf.get_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._set_calculation_object_name_metadata, value)

    _get_direction_metadata = { "offset" : _get_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectDirection),) }
    @property
    def direction(self) -> "CalculationObjectDirection":
        """Get or set the direction to search for the desired value."""
        return self._intf.get_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._get_direction_metadata)

    _set_direction_metadata = { "offset" : _set_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectDirection),) }
    @direction.setter
    def direction(self, value:"CalculationObjectDirection") -> None:
        return self._intf.set_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._set_direction_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativeAtAOLMaster._metadata, StateCalcRelativeAtAOLMaster._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[direction] = "direction"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativeAtAOLMaster."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativeAtAOLMaster)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativeAtAOLMaster, [StateCalcRelativeAtAOLMaster, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4849229807442923025, 3055985504414007725), StateCalcRelativeAtAOLMaster)
agcls.AgTypeNameMap["StateCalcRelativeAtAOLMaster"] = StateCalcRelativeAtAOLMaster

class StateCalcDeltaFromMaster(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Rel Mean Mean Anomaly calculation object."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_reference_selection_method_offset = 3
    _set_reference_selection_method_offset = 4
    _get_reference_method_offset = 5
    _metadata = {
        "iid_data" : (4814878964340470878, 16005736277946868411),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDeltaFromMaster)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object of interest."""
        return self._intf.get_property(StateCalcDeltaFromMaster._metadata, StateCalcDeltaFromMaster._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDeltaFromMaster._metadata, StateCalcDeltaFromMaster._set_calculation_object_name_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcDeltaFromMaster._metadata, StateCalcDeltaFromMaster._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcDeltaFromMaster._metadata, StateCalcDeltaFromMaster._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcDeltaFromMaster._metadata, StateCalcDeltaFromMaster._get_reference_metadata)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDeltaFromMaster."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDeltaFromMaster)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDeltaFromMaster, [StateCalcDeltaFromMaster, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4703993515557400644, 17614379936262850950), StateCalcDeltaFromMaster)
agcls.AgTypeNameMap["StateCalcDeltaFromMaster"] = StateCalcDeltaFromMaster

class StateCalcLonDriftRate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Longitude Drift Rate calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4984696819182526163, 17998640845723229365),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcLonDriftRate)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcLonDriftRate._metadata, StateCalcLonDriftRate._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcLonDriftRate._metadata, StateCalcLonDriftRate._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcLonDriftRate._metadata, StateCalcLonDriftRate._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcLonDriftRate._metadata, StateCalcLonDriftRate._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcLonDriftRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcLonDriftRate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcLonDriftRate, [StateCalcLonDriftRate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4810368111146926421, 10706735339631060658), StateCalcLonDriftRate)
agcls.AgTypeNameMap["StateCalcLonDriftRate"] = StateCalcLonDriftRate

class StateCalcMeanEarthLon(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Mean Earth Longitude calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5644491088733836955, 17171648271203899024),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMeanEarthLon)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcMeanEarthLon._metadata, StateCalcMeanEarthLon._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMeanEarthLon._metadata, StateCalcMeanEarthLon._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMeanEarthLon."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMeanEarthLon)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMeanEarthLon, [StateCalcMeanEarthLon, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4611762585032604408, 12477000884665354939), StateCalcMeanEarthLon)
agcls.AgTypeNameMap["StateCalcMeanEarthLon"] = StateCalcMeanEarthLon

class StateCalcRectifiedLon(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RectifiedLon calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5312716339989036234, 6717266252030860970),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRectifiedLon)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRectifiedLon._metadata, StateCalcRectifiedLon._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRectifiedLon._metadata, StateCalcRectifiedLon._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRectifiedLon."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRectifiedLon)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRectifiedLon, [StateCalcRectifiedLon, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5561226218367470789, 8835336233279258043), StateCalcRectifiedLon)
agcls.AgTypeNameMap["StateCalcRectifiedLon"] = StateCalcRectifiedLon

class StateCalcTrueLongitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a TrueLongitude calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4646564303455954466, 8643954749026340259),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTrueLongitude)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcTrueLongitude._metadata, StateCalcTrueLongitude._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTrueLongitude._metadata, StateCalcTrueLongitude._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTrueLongitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTrueLongitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTrueLongitude, [StateCalcTrueLongitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5081472865222949767, 13080973831116124831), StateCalcTrueLongitude)
agcls.AgTypeNameMap["StateCalcTrueLongitude"] = StateCalcTrueLongitude

class StateCalcGeodeticTrueLongitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a GeodeticTrueLongitude calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5154862674554485027, 12869896454512467592),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGeodeticTrueLongitude)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGeodeticTrueLongitude._metadata, StateCalcGeodeticTrueLongitude._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGeodeticTrueLongitude._metadata, StateCalcGeodeticTrueLongitude._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGeodeticTrueLongitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGeodeticTrueLongitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGeodeticTrueLongitude, [StateCalcGeodeticTrueLongitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5561180435966022811, 7429962574372477857), StateCalcGeodeticTrueLongitude)
agcls.AgTypeNameMap["StateCalcGeodeticTrueLongitude"] = StateCalcGeodeticTrueLongitude

class StateCalcGeodeticTrueLongitudeAtTimeOfPerigee(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a GeodeticTrueLongitudeAtTimeOfPerigee calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5549871358551969066, 16300921313053700520),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGeodeticTrueLongitudeAtTimeOfPerigee)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGeodeticTrueLongitudeAtTimeOfPerigee._metadata, StateCalcGeodeticTrueLongitudeAtTimeOfPerigee._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGeodeticTrueLongitudeAtTimeOfPerigee._metadata, StateCalcGeodeticTrueLongitudeAtTimeOfPerigee._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGeodeticTrueLongitudeAtTimeOfPerigee."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGeodeticTrueLongitudeAtTimeOfPerigee)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGeodeticTrueLongitudeAtTimeOfPerigee, [StateCalcGeodeticTrueLongitudeAtTimeOfPerigee, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5219991753247005554, 16509626988308879526), StateCalcGeodeticTrueLongitudeAtTimeOfPerigee)
agcls.AgTypeNameMap["StateCalcGeodeticTrueLongitudeAtTimeOfPerigee"] = StateCalcGeodeticTrueLongitudeAtTimeOfPerigee

class StateCalcMeanRightAscension(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a MeanRightAscension calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5048103804478321115, 12837897915778585227),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMeanRightAscension)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcMeanRightAscension._metadata, StateCalcMeanRightAscension._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMeanRightAscension._metadata, StateCalcMeanRightAscension._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMeanRightAscension."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMeanRightAscension)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMeanRightAscension, [StateCalcMeanRightAscension, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5672415644848178978, 12226805203773668537), StateCalcMeanRightAscension)
agcls.AgTypeNameMap["StateCalcMeanRightAscension"] = StateCalcMeanRightAscension

class StateCalcGeodeticMeanRightAscension(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a GeodeticMeanRightAscension calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5344325760036946824, 18191401588842309799),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGeodeticMeanRightAscension)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGeodeticMeanRightAscension._metadata, StateCalcGeodeticMeanRightAscension._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGeodeticMeanRightAscension._metadata, StateCalcGeodeticMeanRightAscension._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGeodeticMeanRightAscension."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGeodeticMeanRightAscension)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGeodeticMeanRightAscension, [StateCalcGeodeticMeanRightAscension, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5378244282744007939, 15680331730474888836), StateCalcGeodeticMeanRightAscension)
agcls.AgTypeNameMap["StateCalcGeodeticMeanRightAscension"] = StateCalcGeodeticMeanRightAscension

class StateCalcTwoBodyDriftRate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a TwoBodyDriftRate calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5460810173689551905, 16225637095795943845),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTwoBodyDriftRate)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcTwoBodyDriftRate._metadata, StateCalcTwoBodyDriftRate._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTwoBodyDriftRate._metadata, StateCalcTwoBodyDriftRate._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTwoBodyDriftRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTwoBodyDriftRate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTwoBodyDriftRate, [StateCalcTwoBodyDriftRate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5383774435343665060, 7184945879283363001), StateCalcTwoBodyDriftRate)
agcls.AgTypeNameMap["StateCalcTwoBodyDriftRate"] = StateCalcTwoBodyDriftRate

class StateCalcDriftRateFactor(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a DriftRateFactor calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_drift_rate_model_method_offset = 3
    _set_drift_rate_model_method_offset = 4
    _metadata = {
        "iid_data" : (5330249542569526815, 5634931923199992731),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDriftRateFactor)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcDriftRateFactor._metadata, StateCalcDriftRateFactor._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDriftRateFactor._metadata, StateCalcDriftRateFactor._set_central_body_name_metadata, value)

    _get_drift_rate_model_metadata = { "offset" : _get_drift_rate_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryDriftRateModel),) }
    @property
    def drift_rate_model(self) -> "GeoStationaryDriftRateModel":
        """Get or set the gravity model used to compute drift rate."""
        return self._intf.get_property(StateCalcDriftRateFactor._metadata, StateCalcDriftRateFactor._get_drift_rate_model_metadata)

    _set_drift_rate_model_metadata = { "offset" : _set_drift_rate_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryDriftRateModel),) }
    @drift_rate_model.setter
    def drift_rate_model(self, value:"GeoStationaryDriftRateModel") -> None:
        return self._intf.set_property(StateCalcDriftRateFactor._metadata, StateCalcDriftRateFactor._set_drift_rate_model_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[drift_rate_model] = "drift_rate_model"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDriftRateFactor."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDriftRateFactor)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDriftRateFactor, [StateCalcDriftRateFactor, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5659328086407966292, 4398427823108609201), StateCalcDriftRateFactor)
agcls.AgTypeNameMap["StateCalcDriftRateFactor"] = StateCalcDriftRateFactor

class StateCalcEccentricityX(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a EccentricityX calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4894238426602256437, 17333050540446122149),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEccentricityX)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEccentricityX._metadata, StateCalcEccentricityX._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEccentricityX._metadata, StateCalcEccentricityX._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEccentricityX."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEccentricityX)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEccentricityX, [StateCalcEccentricityX, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4890000948450699546, 11908915193556800643), StateCalcEccentricityX)
agcls.AgTypeNameMap["StateCalcEccentricityX"] = StateCalcEccentricityX

class StateCalcEccentricityY(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a EccentricityY calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4931098808898744401, 15828586612520832163),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEccentricityY)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEccentricityY._metadata, StateCalcEccentricityY._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEccentricityY._metadata, StateCalcEccentricityY._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEccentricityY."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEccentricityY)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEccentricityY, [StateCalcEccentricityY, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5195751570829662446, 17374761392091557022), StateCalcEccentricityY)
agcls.AgTypeNameMap["StateCalcEccentricityY"] = StateCalcEccentricityY

class StateCalcInclinationX(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a InclinationX calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_inclination_magnitude_type_method_offset = 3
    _set_inclination_magnitude_type_method_offset = 4
    _metadata = {
        "iid_data" : (5303116798892466546, 8652600110648124591),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInclinationX)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcInclinationX._metadata, StateCalcInclinationX._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInclinationX._metadata, StateCalcInclinationX._set_central_body_name_metadata, value)

    _get_inclination_magnitude_type_metadata = { "offset" : _get_inclination_magnitude_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryInclinationMagnitude),) }
    @property
    def inclination_magnitude_type(self) -> "GeoStationaryInclinationMagnitude":
        """Magnitude to use when computing the inclination vector."""
        return self._intf.get_property(StateCalcInclinationX._metadata, StateCalcInclinationX._get_inclination_magnitude_type_metadata)

    _set_inclination_magnitude_type_metadata = { "offset" : _set_inclination_magnitude_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryInclinationMagnitude),) }
    @inclination_magnitude_type.setter
    def inclination_magnitude_type(self, value:"GeoStationaryInclinationMagnitude") -> None:
        return self._intf.set_property(StateCalcInclinationX._metadata, StateCalcInclinationX._set_inclination_magnitude_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[inclination_magnitude_type] = "inclination_magnitude_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInclinationX."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInclinationX)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInclinationX, [StateCalcInclinationX, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5343058450031167507, 16391122691667095461), StateCalcInclinationX)
agcls.AgTypeNameMap["StateCalcInclinationX"] = StateCalcInclinationX

class StateCalcInclinationY(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a InclinationY calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_inclination_magnitude_type_method_offset = 3
    _set_inclination_magnitude_type_method_offset = 4
    _metadata = {
        "iid_data" : (5451370693498009019, 10642033776934022825),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInclinationY)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcInclinationY._metadata, StateCalcInclinationY._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInclinationY._metadata, StateCalcInclinationY._set_central_body_name_metadata, value)

    _get_inclination_magnitude_type_metadata = { "offset" : _get_inclination_magnitude_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryInclinationMagnitude),) }
    @property
    def inclination_magnitude_type(self) -> "GeoStationaryInclinationMagnitude":
        """Magnitude to use when computing the inclination vector."""
        return self._intf.get_property(StateCalcInclinationY._metadata, StateCalcInclinationY._get_inclination_magnitude_type_metadata)

    _set_inclination_magnitude_type_metadata = { "offset" : _set_inclination_magnitude_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoStationaryInclinationMagnitude),) }
    @inclination_magnitude_type.setter
    def inclination_magnitude_type(self, value:"GeoStationaryInclinationMagnitude") -> None:
        return self._intf.set_property(StateCalcInclinationY._metadata, StateCalcInclinationY._set_inclination_magnitude_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[inclination_magnitude_type] = "inclination_magnitude_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInclinationY."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInclinationY)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInclinationY, [StateCalcInclinationY, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4863529585957113128, 10102237046352894897), StateCalcInclinationY)
agcls.AgTypeNameMap["StateCalcInclinationY"] = StateCalcInclinationY

class StateCalcUnitAngularMomentumX(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a UnitAngularMomentumX calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4867031833350884905, 3301894672569955263),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcUnitAngularMomentumX)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcUnitAngularMomentumX._metadata, StateCalcUnitAngularMomentumX._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcUnitAngularMomentumX._metadata, StateCalcUnitAngularMomentumX._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcUnitAngularMomentumX."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcUnitAngularMomentumX)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcUnitAngularMomentumX, [StateCalcUnitAngularMomentumX, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5447705866460823284, 13783482782719490212), StateCalcUnitAngularMomentumX)
agcls.AgTypeNameMap["StateCalcUnitAngularMomentumX"] = StateCalcUnitAngularMomentumX

class StateCalcUnitAngularMomentumY(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a UnitAngularMomentumY calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4620132140076523895, 14996909192432193432),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcUnitAngularMomentumY)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcUnitAngularMomentumY._metadata, StateCalcUnitAngularMomentumY._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcUnitAngularMomentumY._metadata, StateCalcUnitAngularMomentumY._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcUnitAngularMomentumY."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcUnitAngularMomentumY)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcUnitAngularMomentumY, [StateCalcUnitAngularMomentumY, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4786968704254907389, 13158431096979751558), StateCalcUnitAngularMomentumY)
agcls.AgTypeNameMap["StateCalcUnitAngularMomentumY"] = StateCalcUnitAngularMomentumY

class StateCalcUnitAngularMomentumZ(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a UnitAngularMomentumZ calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5157286771188626290, 103471323176308659),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcUnitAngularMomentumZ)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcUnitAngularMomentumZ._metadata, StateCalcUnitAngularMomentumZ._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcUnitAngularMomentumZ._metadata, StateCalcUnitAngularMomentumZ._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcUnitAngularMomentumZ."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcUnitAngularMomentumZ)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcUnitAngularMomentumZ, [StateCalcUnitAngularMomentumZ, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5431982115791144105, 4613613462980346503), StateCalcUnitAngularMomentumZ)
agcls.AgTypeNameMap["StateCalcUnitAngularMomentumZ"] = StateCalcUnitAngularMomentumZ

class StateCalcHeightAboveTerrain(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for StateCalcHeightAboveTerrain."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5001830471771159235, 8470443678088309179),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcHeightAboveTerrain)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Central Body used for calculation."""
        return self._intf.get_property(StateCalcHeightAboveTerrain._metadata, StateCalcHeightAboveTerrain._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        """Central Body used for calculation."""
        return self._intf.set_property(StateCalcHeightAboveTerrain._metadata, StateCalcHeightAboveTerrain._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcHeightAboveTerrain."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcHeightAboveTerrain)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcHeightAboveTerrain, [StateCalcHeightAboveTerrain, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5679191460559336989, 1313569402354780308), StateCalcHeightAboveTerrain)
agcls.AgTypeNameMap["StateCalcHeightAboveTerrain"] = StateCalcHeightAboveTerrain

class StateCalcGeodeticElem(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Geodetic Element calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4669942275556971148, 5814687713330014126),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGeodeticElem)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGeodeticElem._metadata, StateCalcGeodeticElem._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGeodeticElem._metadata, StateCalcGeodeticElem._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGeodeticElem."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGeodeticElem)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGeodeticElem, [StateCalcGeodeticElem, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5368597638791724835, 15722023724069301167), StateCalcGeodeticElem)
agcls.AgTypeNameMap["StateCalcGeodeticElem"] = StateCalcGeodeticElem

class StateCalcRepeatingGroundTrackErr(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RepeatingGroundTrackEquatorError calculation object."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_longitude_method_offset = 3
    _set_reference_longitude_method_offset = 4
    _get_repeat_count_method_offset = 5
    _set_repeat_count_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (4823386117493643824, 1763726539818968494),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRepeatingGroundTrackErr)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._set_central_body_name_metadata, value)

    _get_reference_longitude_metadata = { "offset" : _get_reference_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def reference_longitude(self) -> typing.Any:
        """Get or set the longitude at the equator to be used as a reference for the repeating ground track. Uses Angle Dimension."""
        return self._intf.get_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._get_reference_longitude_metadata)

    _set_reference_longitude_metadata = { "offset" : _set_reference_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @reference_longitude.setter
    def reference_longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._set_reference_longitude_metadata, value)

    _get_repeat_count_metadata = { "offset" : _get_repeat_count_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def repeat_count(self) -> float:
        """Get or set the number of orbits before the ground track repeats over the same longitude. Dimensionless."""
        return self._intf.get_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._get_repeat_count_metadata)

    _set_repeat_count_metadata = { "offset" : _set_repeat_count_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @repeat_count.setter
    def repeat_count(self, value:float) -> None:
        return self._intf.set_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._set_repeat_count_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlRepeatingGroundTrackErr),) }
    def enable_control_parameter(self, param:"ControlRepeatingGroundTrackErr") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlRepeatingGroundTrackErr),) }
    def disable_control_parameter(self, param:"ControlRepeatingGroundTrackErr") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlRepeatingGroundTrackErr), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlRepeatingGroundTrackErr") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(StateCalcRepeatingGroundTrackErr._metadata, StateCalcRepeatingGroundTrackErr._get_control_parameters_available_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_longitude] = "reference_longitude"
    _property_names[repeat_count] = "repeat_count"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRepeatingGroundTrackErr."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRepeatingGroundTrackErr)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRepeatingGroundTrackErr, [StateCalcRepeatingGroundTrackErr, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4802952676793573249, 3742314941598062748), StateCalcRepeatingGroundTrackErr)
agcls.AgTypeNameMap["StateCalcRepeatingGroundTrackErr"] = StateCalcRepeatingGroundTrackErr

class StateCalcAltitudeOfApoapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Altitude of Apoapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4804961906984959380, 3379445527920073108),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcAltitudeOfApoapsis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcAltitudeOfApoapsis._metadata, StateCalcAltitudeOfApoapsis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcAltitudeOfApoapsis._metadata, StateCalcAltitudeOfApoapsis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcAltitudeOfApoapsis._metadata, StateCalcAltitudeOfApoapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcAltitudeOfApoapsis._metadata, StateCalcAltitudeOfApoapsis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcAltitudeOfApoapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcAltitudeOfApoapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcAltitudeOfApoapsis, [StateCalcAltitudeOfApoapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4680045279095392866, 2885707908870599052), StateCalcAltitudeOfApoapsis)
agcls.AgTypeNameMap["StateCalcAltitudeOfApoapsis"] = StateCalcAltitudeOfApoapsis

class StateCalcAltitudeOfPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Altitude Of Periapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4737053168431653768, 6669250612885585032),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcAltitudeOfPeriapsis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcAltitudeOfPeriapsis._metadata, StateCalcAltitudeOfPeriapsis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcAltitudeOfPeriapsis._metadata, StateCalcAltitudeOfPeriapsis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcAltitudeOfPeriapsis._metadata, StateCalcAltitudeOfPeriapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcAltitudeOfPeriapsis._metadata, StateCalcAltitudeOfPeriapsis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcAltitudeOfPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcAltitudeOfPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcAltitudeOfPeriapsis, [StateCalcAltitudeOfPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5711549813926167011, 172247784438999984), StateCalcAltitudeOfPeriapsis)
agcls.AgTypeNameMap["StateCalcAltitudeOfPeriapsis"] = StateCalcAltitudeOfPeriapsis

class StateCalcArgumentOfLatitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Argument of Latitude calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4646620714499650179, 13630006269487185795),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcArgumentOfLatitude)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcArgumentOfLatitude._metadata, StateCalcArgumentOfLatitude._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcArgumentOfLatitude._metadata, StateCalcArgumentOfLatitude._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcArgumentOfLatitude._metadata, StateCalcArgumentOfLatitude._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcArgumentOfLatitude._metadata, StateCalcArgumentOfLatitude._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcArgumentOfLatitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcArgumentOfLatitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcArgumentOfLatitude, [StateCalcArgumentOfLatitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5721561101168071631, 8215502116176583064), StateCalcArgumentOfLatitude)
agcls.AgTypeNameMap["StateCalcArgumentOfLatitude"] = StateCalcArgumentOfLatitude

class StateCalcArgumentOfPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Argument of Periapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5751021743421934462, 1138987020898760380),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcArgumentOfPeriapsis)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcArgumentOfPeriapsis._metadata, StateCalcArgumentOfPeriapsis._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcArgumentOfPeriapsis._metadata, StateCalcArgumentOfPeriapsis._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcArgumentOfPeriapsis._metadata, StateCalcArgumentOfPeriapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcArgumentOfPeriapsis._metadata, StateCalcArgumentOfPeriapsis._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcArgumentOfPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcArgumentOfPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcArgumentOfPeriapsis, [StateCalcArgumentOfPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5684255884981629138, 3677058005489362621), StateCalcArgumentOfPeriapsis)
agcls.AgTypeNameMap["StateCalcArgumentOfPeriapsis"] = StateCalcArgumentOfPeriapsis

class StateCalcEccentricityAnomaly(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Eccentric Anomaly calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5641923176315593130, 5159228630191255194),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEccentricityAnomaly)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEccentricityAnomaly._metadata, StateCalcEccentricityAnomaly._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEccentricityAnomaly._metadata, StateCalcEccentricityAnomaly._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcEccentricityAnomaly._metadata, StateCalcEccentricityAnomaly._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcEccentricityAnomaly._metadata, StateCalcEccentricityAnomaly._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEccentricityAnomaly."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEccentricityAnomaly)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEccentricityAnomaly, [StateCalcEccentricityAnomaly, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5472882556788075591, 6568513677222152077), StateCalcEccentricityAnomaly)
agcls.AgTypeNameMap["StateCalcEccentricityAnomaly"] = StateCalcEccentricityAnomaly

class StateCalcLonOfAscNode(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Longitude of Ascending Node calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4943815842015931666, 10560249350701891763),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcLonOfAscNode)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcLonOfAscNode._metadata, StateCalcLonOfAscNode._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcLonOfAscNode._metadata, StateCalcLonOfAscNode._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcLonOfAscNode._metadata, StateCalcLonOfAscNode._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcLonOfAscNode._metadata, StateCalcLonOfAscNode._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcLonOfAscNode."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcLonOfAscNode)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcLonOfAscNode, [StateCalcLonOfAscNode, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4869631541520654432, 2995754984005813684), StateCalcLonOfAscNode)
agcls.AgTypeNameMap["StateCalcLonOfAscNode"] = StateCalcLonOfAscNode

class StateCalcMeanMotion(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Mean Motion calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5272477230544721892, 16800233696536864958),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMeanMotion)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcMeanMotion._metadata, StateCalcMeanMotion._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMeanMotion._metadata, StateCalcMeanMotion._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcMeanMotion._metadata, StateCalcMeanMotion._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcMeanMotion._metadata, StateCalcMeanMotion._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMeanMotion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMeanMotion)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMeanMotion, [StateCalcMeanMotion, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4747596417491606013, 15395657420428995495), StateCalcMeanMotion)
agcls.AgTypeNameMap["StateCalcMeanMotion"] = StateCalcMeanMotion

class StateCalcOrbitPeriod(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Orbit Period calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4613752124273608812, 15403231600106864030),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitPeriod)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcOrbitPeriod._metadata, StateCalcOrbitPeriod._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOrbitPeriod._metadata, StateCalcOrbitPeriod._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcOrbitPeriod._metadata, StateCalcOrbitPeriod._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcOrbitPeriod._metadata, StateCalcOrbitPeriod._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitPeriod."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitPeriod)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitPeriod, [StateCalcOrbitPeriod, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4883509369718059623, 9523723199357936256), StateCalcOrbitPeriod)
agcls.AgTypeNameMap["StateCalcOrbitPeriod"] = StateCalcOrbitPeriod

class StateCalcNumRevs(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Number of Revolutions calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4967851475699997060, 9372108415445250466),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcNumRevs)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcNumRevs._metadata, StateCalcNumRevs._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcNumRevs._metadata, StateCalcNumRevs._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcNumRevs._metadata, StateCalcNumRevs._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcNumRevs._metadata, StateCalcNumRevs._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcNumRevs."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcNumRevs)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcNumRevs, [StateCalcNumRevs, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5128543494425042730, 1166581705760978097), StateCalcNumRevs)
agcls.AgTypeNameMap["StateCalcNumRevs"] = StateCalcNumRevs

class StateCalcRadOfApoapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Radius Of Apoapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4965803044756787528, 17018162359568687774),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRadOfApoapsis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRadOfApoapsis._metadata, StateCalcRadOfApoapsis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRadOfApoapsis._metadata, StateCalcRadOfApoapsis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcRadOfApoapsis._metadata, StateCalcRadOfApoapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRadOfApoapsis._metadata, StateCalcRadOfApoapsis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRadOfApoapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRadOfApoapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRadOfApoapsis, [StateCalcRadOfApoapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5610435208412011938, 15680633327063310238), StateCalcRadOfApoapsis)
agcls.AgTypeNameMap["StateCalcRadOfApoapsis"] = StateCalcRadOfApoapsis

class StateCalcRadOfPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Radius Of Periapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5130986865795971189, 16789141452098079673),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRadOfPeriapsis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRadOfPeriapsis._metadata, StateCalcRadOfPeriapsis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRadOfPeriapsis._metadata, StateCalcRadOfPeriapsis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcRadOfPeriapsis._metadata, StateCalcRadOfPeriapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRadOfPeriapsis._metadata, StateCalcRadOfPeriapsis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRadOfPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRadOfPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRadOfPeriapsis, [StateCalcRadOfPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4913547247352946746, 6032480820430129067), StateCalcRadOfPeriapsis)
agcls.AgTypeNameMap["StateCalcRadOfPeriapsis"] = StateCalcRadOfPeriapsis

class StateCalcSemimajorAxis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Semimajor Axis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5590870916411176225, 16124915921295777960),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSemimajorAxis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcSemimajorAxis._metadata, StateCalcSemimajorAxis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSemimajorAxis._metadata, StateCalcSemimajorAxis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcSemimajorAxis._metadata, StateCalcSemimajorAxis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcSemimajorAxis._metadata, StateCalcSemimajorAxis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSemimajorAxis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSemimajorAxis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSemimajorAxis, [StateCalcSemimajorAxis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5118541904447365438, 10801378442445865622), StateCalcSemimajorAxis)
agcls.AgTypeNameMap["StateCalcSemimajorAxis"] = StateCalcSemimajorAxis

class StateCalcTimePastAscNode(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Time Past Ascending Node calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5562589395377256243, 13497037947049292677),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTimePastAscNode)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcTimePastAscNode._metadata, StateCalcTimePastAscNode._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTimePastAscNode._metadata, StateCalcTimePastAscNode._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcTimePastAscNode._metadata, StateCalcTimePastAscNode._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcTimePastAscNode._metadata, StateCalcTimePastAscNode._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTimePastAscNode."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTimePastAscNode)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTimePastAscNode, [StateCalcTimePastAscNode, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5564567196649759285, 9406082925819798685), StateCalcTimePastAscNode)
agcls.AgTypeNameMap["StateCalcTimePastAscNode"] = StateCalcTimePastAscNode

class StateCalcTimePastPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Time Past Periapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5684995327153450736, 9483471647629985712),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTimePastPeriapsis)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcTimePastPeriapsis._metadata, StateCalcTimePastPeriapsis._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTimePastPeriapsis._metadata, StateCalcTimePastPeriapsis._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcTimePastPeriapsis._metadata, StateCalcTimePastPeriapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcTimePastPeriapsis._metadata, StateCalcTimePastPeriapsis._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTimePastPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTimePastPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTimePastPeriapsis, [StateCalcTimePastPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5407430146817268966, 10284458395368679078), StateCalcTimePastPeriapsis)
agcls.AgTypeNameMap["StateCalcTimePastPeriapsis"] = StateCalcTimePastPeriapsis

class StateCalcTrueAnomaly(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Mean True Anomaly calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5315225285503473966, 17168653625677065383),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTrueAnomaly)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcTrueAnomaly._metadata, StateCalcTrueAnomaly._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTrueAnomaly._metadata, StateCalcTrueAnomaly._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcTrueAnomaly._metadata, StateCalcTrueAnomaly._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcTrueAnomaly._metadata, StateCalcTrueAnomaly._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTrueAnomaly."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTrueAnomaly)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTrueAnomaly, [StateCalcTrueAnomaly, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5111376757081525828, 8458902587457567926), StateCalcTrueAnomaly)
agcls.AgTypeNameMap["StateCalcTrueAnomaly"] = StateCalcTrueAnomaly

class StateCalcDeltaV(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a DeltaV calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5534952825540803418, 13420343991370104736),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDeltaV)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDeltaV."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDeltaV)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDeltaV, [StateCalcDeltaV, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5735205105008486861, 4958177406641049504), StateCalcDeltaV)
agcls.AgTypeNameMap["StateCalcDeltaV"] = StateCalcDeltaV

class StateCalcDeltaVSquared(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a DeltaV Squared calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5704565883071914391, 3071057530161522337),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDeltaVSquared)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDeltaVSquared."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDeltaVSquared)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDeltaVSquared, [StateCalcDeltaVSquared, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5018999258309169900, 18294161584335658669), StateCalcDeltaVSquared)
agcls.AgTypeNameMap["StateCalcDeltaVSquared"] = StateCalcDeltaVSquared

class StateCalcMCSDeltaV(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a MCS DeltaV calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5316237708087118868, 6452972329347706796),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMCSDeltaV)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMCSDeltaV."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMCSDeltaV)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMCSDeltaV, [StateCalcMCSDeltaV, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5376311996187022567, 10704423917084038577), StateCalcMCSDeltaV)
agcls.AgTypeNameMap["StateCalcMCSDeltaV"] = StateCalcMCSDeltaV

class StateCalcMCSDeltaVSquared(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a MCS DeltaV Squared calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_squared_type_method_offset = 1
    _set_squared_type_method_offset = 2
    _metadata = {
        "iid_data" : (4645033948798417354, 9487747245930481071),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMCSDeltaVSquared)

    _get_squared_type_metadata = { "offset" : _get_squared_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SquaredType),) }
    @property
    def squared_type(self) -> "SquaredType":
        """Whether the value should be calculated as the sum of the squares of the maneuver Delta-Vs or the square of the sum of the maneuver Delta-Vs."""
        return self._intf.get_property(StateCalcMCSDeltaVSquared._metadata, StateCalcMCSDeltaVSquared._get_squared_type_metadata)

    _set_squared_type_metadata = { "offset" : _set_squared_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SquaredType),) }
    @squared_type.setter
    def squared_type(self, value:"SquaredType") -> None:
        """Whether the value should be calculated as the sum of the squares of the maneuver Delta-Vs or the square of the sum of the maneuver Delta-Vs."""
        return self._intf.set_property(StateCalcMCSDeltaVSquared._metadata, StateCalcMCSDeltaVSquared._set_squared_type_metadata, value)

    _property_names[squared_type] = "squared_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMCSDeltaVSquared."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMCSDeltaVSquared)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMCSDeltaVSquared, [StateCalcMCSDeltaVSquared, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5628482244802819265, 12608246510277330571), StateCalcMCSDeltaVSquared)
agcls.AgTypeNameMap["StateCalcMCSDeltaVSquared"] = StateCalcMCSDeltaVSquared

class StateCalcSequenceDeltaV(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Sequence DeltaV calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_sequence_name_method_offset = 1
    _set_sequence_name_method_offset = 2
    _metadata = {
        "iid_data" : (4633447003068296805, 2676702751796205994),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSequenceDeltaV)

    _get_sequence_name_metadata = { "offset" : _get_sequence_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def sequence_name(self) -> str:
        """Get or set the sequence whose DeltaV's are to be summed."""
        return self._intf.get_property(StateCalcSequenceDeltaV._metadata, StateCalcSequenceDeltaV._get_sequence_name_metadata)

    _set_sequence_name_metadata = { "offset" : _set_sequence_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @sequence_name.setter
    def sequence_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSequenceDeltaV._metadata, StateCalcSequenceDeltaV._set_sequence_name_metadata, value)

    _property_names[sequence_name] = "sequence_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSequenceDeltaV."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSequenceDeltaV)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSequenceDeltaV, [StateCalcSequenceDeltaV, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5097550551983029190, 1249982837446207875), StateCalcSequenceDeltaV)
agcls.AgTypeNameMap["StateCalcSequenceDeltaV"] = StateCalcSequenceDeltaV

class StateCalcSequenceDeltaVSquared(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Sequence DeltaV Squared calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_sequence_name_method_offset = 1
    _set_sequence_name_method_offset = 2
    _get_squared_type_method_offset = 3
    _set_squared_type_method_offset = 4
    _metadata = {
        "iid_data" : (5635671843908320145, 4152975408965574534),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSequenceDeltaVSquared)

    _get_sequence_name_metadata = { "offset" : _get_sequence_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def sequence_name(self) -> str:
        """Get or set the sequence whose DeltaV's are to be accumulated."""
        return self._intf.get_property(StateCalcSequenceDeltaVSquared._metadata, StateCalcSequenceDeltaVSquared._get_sequence_name_metadata)

    _set_sequence_name_metadata = { "offset" : _set_sequence_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @sequence_name.setter
    def sequence_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSequenceDeltaVSquared._metadata, StateCalcSequenceDeltaVSquared._set_sequence_name_metadata, value)

    _get_squared_type_metadata = { "offset" : _get_squared_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SquaredType),) }
    @property
    def squared_type(self) -> "SquaredType":
        """Whether the value should be calculated as the sum of the squares of the maneuver Delta-Vs or the square of the sum of the maneuver Delta-Vs."""
        return self._intf.get_property(StateCalcSequenceDeltaVSquared._metadata, StateCalcSequenceDeltaVSquared._get_squared_type_metadata)

    _set_squared_type_metadata = { "offset" : _set_squared_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SquaredType),) }
    @squared_type.setter
    def squared_type(self, value:"SquaredType") -> None:
        """Whether the value should be calculated as the sum of the squares of the maneuver Delta-Vs or the square of the sum of the maneuver Delta-Vs."""
        return self._intf.set_property(StateCalcSequenceDeltaVSquared._metadata, StateCalcSequenceDeltaVSquared._set_squared_type_metadata, value)

    _property_names[sequence_name] = "sequence_name"
    _property_names[squared_type] = "squared_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSequenceDeltaVSquared."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSequenceDeltaVSquared)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSequenceDeltaVSquared, [StateCalcSequenceDeltaVSquared, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5630825541610308831, 15774632184071493555), StateCalcSequenceDeltaVSquared)
agcls.AgTypeNameMap["StateCalcSequenceDeltaVSquared"] = StateCalcSequenceDeltaVSquared

class StateCalcFuelMass(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a FuelMass calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5151428709425076440, 7487392127807473330),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcFuelMass)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcFuelMass."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcFuelMass)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcFuelMass, [StateCalcFuelMass, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5332377876689301450, 9083355359145196446), StateCalcFuelMass)
agcls.AgTypeNameMap["StateCalcFuelMass"] = StateCalcFuelMass

class StateCalcDensity(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Fuel Density calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5017809731874998764, 8924756791837866658),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDensity)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDensity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDensity)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDensity, [StateCalcDensity, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5430632087509559798, 9149872271344420512), StateCalcDensity)
agcls.AgTypeNameMap["StateCalcDensity"] = StateCalcDensity

class StateCalcInertialDeltaVMagnitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Inertial DeltaV Magnitude calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5655263703535879206, 14229486467541672352),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInertialDeltaVMagnitude)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInertialDeltaVMagnitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInertialDeltaVMagnitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInertialDeltaVMagnitude, [StateCalcInertialDeltaVMagnitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4886899391864671900, 15236932873941812910), StateCalcInertialDeltaVMagnitude)
agcls.AgTypeNameMap["StateCalcInertialDeltaVMagnitude"] = StateCalcInertialDeltaVMagnitude

class StateCalcInertialDeltaVx(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Inertial DeltaVx calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _metadata = {
        "iid_data" : (5147140685656921702, 2892503026461819017),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInertialDeltaVx)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcInertialDeltaVx._metadata, StateCalcInertialDeltaVx._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInertialDeltaVx._metadata, StateCalcInertialDeltaVx._set_coord_axes_name_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInertialDeltaVx."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInertialDeltaVx)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInertialDeltaVx, [StateCalcInertialDeltaVx, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4821595772988904722, 12220769280307415212), StateCalcInertialDeltaVx)
agcls.AgTypeNameMap["StateCalcInertialDeltaVx"] = StateCalcInertialDeltaVx

class StateCalcInertialDeltaVy(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Inertial DeltaVy calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _metadata = {
        "iid_data" : (5535239348503742884, 15276188469658558399),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInertialDeltaVy)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcInertialDeltaVy._metadata, StateCalcInertialDeltaVy._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInertialDeltaVy._metadata, StateCalcInertialDeltaVy._set_coord_axes_name_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInertialDeltaVy."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInertialDeltaVy)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInertialDeltaVy, [StateCalcInertialDeltaVy, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4855464037190244874, 3375418175855904949), StateCalcInertialDeltaVy)
agcls.AgTypeNameMap["StateCalcInertialDeltaVy"] = StateCalcInertialDeltaVy

class StateCalcInertialDeltaVz(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Inertial DeltaVz calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _metadata = {
        "iid_data" : (4691307025227964777, 13663375653406686621),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInertialDeltaVz)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcInertialDeltaVz._metadata, StateCalcInertialDeltaVz._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInertialDeltaVz._metadata, StateCalcInertialDeltaVz._set_coord_axes_name_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInertialDeltaVz."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInertialDeltaVz)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInertialDeltaVz, [StateCalcInertialDeltaVz, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4822846875597407381, 13296331241838685581), StateCalcInertialDeltaVz)
agcls.AgTypeNameMap["StateCalcInertialDeltaVz"] = StateCalcInertialDeltaVz

class StateCalcManeuverSpecificImpulse(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Specific Impulse calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4637712452113764989, 15886083855590906538),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcManeuverSpecificImpulse)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcManeuverSpecificImpulse."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcManeuverSpecificImpulse)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcManeuverSpecificImpulse, [StateCalcManeuverSpecificImpulse, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4622503106430628545, 6107233881266172821), StateCalcManeuverSpecificImpulse)
agcls.AgTypeNameMap["StateCalcManeuverSpecificImpulse"] = StateCalcManeuverSpecificImpulse

class StateCalcPressure(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Tank Pressure calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5449490418666210004, 15448348542096366226),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcPressure)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcPressure."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcPressure)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcPressure, [StateCalcPressure, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4794915601194535984, 5940540998251569597), StateCalcPressure)
agcls.AgTypeNameMap["StateCalcPressure"] = StateCalcPressure

class StateCalcTemperature(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Tank Temperature calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5475729774530559001, 10941078062920403866),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTemperature)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTemperature."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTemperature)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTemperature, [StateCalcTemperature, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5536041037581480431, 10686749433105631157), StateCalcTemperature)
agcls.AgTypeNameMap["StateCalcTemperature"] = StateCalcTemperature

class StateCalcVectorY(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector Y calculation object."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _get_vector_name_method_offset = 3
    _set_vector_name_method_offset = 4
    _get_unit_dimension_method_offset = 5
    _set_unit_dimension_method_offset = 6
    _get_normalize_method_offset = 7
    _set_normalize_method_offset = 8
    _metadata = {
        "iid_data" : (5267983331101176658, 9823313191056859545),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorY)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcVectorY._metadata, StateCalcVectorY._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorY._metadata, StateCalcVectorY._set_coord_axes_name_metadata, value)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorY._metadata, StateCalcVectorY._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorY._metadata, StateCalcVectorY._set_vector_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcVectorY._metadata, StateCalcVectorY._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorY._metadata, StateCalcVectorY._set_unit_dimension_metadata, value)

    _get_normalize_metadata = { "offset" : _get_normalize_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def normalize(self) -> bool:
        """If true, return the normalized magnitude."""
        return self._intf.get_property(StateCalcVectorY._metadata, StateCalcVectorY._get_normalize_metadata)

    _set_normalize_metadata = { "offset" : _set_normalize_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @normalize.setter
    def normalize(self, value:bool) -> None:
        return self._intf.set_property(StateCalcVectorY._metadata, StateCalcVectorY._set_normalize_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"
    _property_names[vector_name] = "vector_name"
    _property_names[unit_dimension] = "unit_dimension"
    _property_names[normalize] = "normalize"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorY."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorY)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorY, [StateCalcVectorY, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5421805410493711150, 17871064854232439969), StateCalcVectorY)
agcls.AgTypeNameMap["StateCalcVectorY"] = StateCalcVectorY

class StateCalcVectorZ(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector Z calculation object."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _get_vector_name_method_offset = 3
    _set_vector_name_method_offset = 4
    _get_unit_dimension_method_offset = 5
    _set_unit_dimension_method_offset = 6
    _get_normalize_method_offset = 7
    _set_normalize_method_offset = 8
    _metadata = {
        "iid_data" : (5252175952045025930, 153518083256492710),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorZ)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcVectorZ._metadata, StateCalcVectorZ._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorZ._metadata, StateCalcVectorZ._set_coord_axes_name_metadata, value)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorZ._metadata, StateCalcVectorZ._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorZ._metadata, StateCalcVectorZ._set_vector_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcVectorZ._metadata, StateCalcVectorZ._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorZ._metadata, StateCalcVectorZ._set_unit_dimension_metadata, value)

    _get_normalize_metadata = { "offset" : _get_normalize_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def normalize(self) -> bool:
        """If true, return the normalized magnitude."""
        return self._intf.get_property(StateCalcVectorZ._metadata, StateCalcVectorZ._get_normalize_metadata)

    _set_normalize_metadata = { "offset" : _set_normalize_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @normalize.setter
    def normalize(self, value:bool) -> None:
        return self._intf.set_property(StateCalcVectorZ._metadata, StateCalcVectorZ._set_normalize_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"
    _property_names[vector_name] = "vector_name"
    _property_names[unit_dimension] = "unit_dimension"
    _property_names[normalize] = "normalize"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorZ."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorZ)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorZ, [StateCalcVectorZ, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5216554707482900455, 10991111390992105651), StateCalcVectorZ)
agcls.AgTypeNameMap["StateCalcVectorZ"] = StateCalcVectorZ

class StateCalcMass(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Total Mass calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4824138427327990760, 14867348190747208111),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMass)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMass."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMass)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMass, [StateCalcMass, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4997657165484082210, 3541058383396595871), StateCalcMass)
agcls.AgTypeNameMap["StateCalcMass"] = StateCalcMass

class StateCalcManeuverTotalMassFlowRate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Total Mass Flow Rate calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5526044805283548379, 10435494578370294662),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcManeuverTotalMassFlowRate)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcManeuverTotalMassFlowRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcManeuverTotalMassFlowRate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcManeuverTotalMassFlowRate, [StateCalcManeuverTotalMassFlowRate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5504217790692566183, 3415641010481336239), StateCalcManeuverTotalMassFlowRate)
agcls.AgTypeNameMap["StateCalcManeuverTotalMassFlowRate"] = StateCalcManeuverTotalMassFlowRate

class StateCalcAbsoluteValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Absolute Value calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5242501412076507984, 7725825147363795095),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcAbsoluteValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcAbsoluteValue._metadata, StateCalcAbsoluteValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcAbsoluteValue._metadata, StateCalcAbsoluteValue._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcAbsoluteValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcAbsoluteValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcAbsoluteValue, [StateCalcAbsoluteValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5649254655531211135, 6218154849600881073), StateCalcAbsoluteValue)
agcls.AgTypeNameMap["StateCalcAbsoluteValue"] = StateCalcAbsoluteValue

class StateCalcDifference(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Difference calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_difference_order_method_offset = 3
    _set_difference_order_method_offset = 4
    _metadata = {
        "iid_data" : (5286816172224215455, 1036938080734512060),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDifference)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcDifference._metadata, StateCalcDifference._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDifference._metadata, StateCalcDifference._set_calculation_object_name_metadata, value)

    _get_difference_order_metadata = { "offset" : _get_difference_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DifferenceOrder),) }
    @property
    def difference_order(self) -> "DifferenceOrder":
        """Get or set the order of the difference calculation."""
        return self._intf.get_property(StateCalcDifference._metadata, StateCalcDifference._get_difference_order_metadata)

    _set_difference_order_metadata = { "offset" : _set_difference_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DifferenceOrder),) }
    @difference_order.setter
    def difference_order(self, value:"DifferenceOrder") -> None:
        return self._intf.set_property(StateCalcDifference._metadata, StateCalcDifference._set_difference_order_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[difference_order] = "difference_order"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDifference."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDifference)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDifference, [StateCalcDifference, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5521971242167934141, 6064248763181856402), StateCalcDifference)
agcls.AgTypeNameMap["StateCalcDifference"] = StateCalcDifference

class StateCalcDifferenceOtherSegment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Difference Across Segments calculation object."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_other_segment_name_method_offset = 3
    _set_other_segment_name_method_offset = 4
    _get_segment_state_to_use_method_offset = 5
    _set_segment_state_to_use_method_offset = 6
    _get_difference_order_method_offset = 7
    _set_difference_order_method_offset = 8
    _metadata = {
        "iid_data" : (4838331601109046283, 10861212503697690540),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDifferenceOtherSegment)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._set_calculation_object_name_metadata, value)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._set_segment_state_to_use_metadata, value)

    _get_difference_order_metadata = { "offset" : _get_difference_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentDifferenceOrder),) }
    @property
    def difference_order(self) -> "SegmentDifferenceOrder":
        """Get or set the order of the difference calculation."""
        return self._intf.get_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._get_difference_order_metadata)

    _set_difference_order_metadata = { "offset" : _set_difference_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentDifferenceOrder),) }
    @difference_order.setter
    def difference_order(self, value:"SegmentDifferenceOrder") -> None:
        return self._intf.set_property(StateCalcDifferenceOtherSegment._metadata, StateCalcDifferenceOtherSegment._set_difference_order_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"
    _property_names[difference_order] = "difference_order"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDifferenceOtherSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDifferenceOtherSegment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDifferenceOtherSegment, [StateCalcDifferenceOtherSegment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5714208844396347834, 5962452290304441480), StateCalcDifferenceOtherSegment)
agcls.AgTypeNameMap["StateCalcDifferenceOtherSegment"] = StateCalcDifferenceOtherSegment

class StateCalcPositionDifferenceOtherSegment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Position Difference Across Segments calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_other_segment_name_method_offset = 1
    _set_other_segment_name_method_offset = 2
    _get_segment_state_to_use_method_offset = 3
    _set_segment_state_to_use_method_offset = 4
    _metadata = {
        "iid_data" : (4976467856226832650, 9795326462409064358),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcPositionDifferenceOtherSegment)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcPositionDifferenceOtherSegment._metadata, StateCalcPositionDifferenceOtherSegment._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcPositionDifferenceOtherSegment._metadata, StateCalcPositionDifferenceOtherSegment._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcPositionDifferenceOtherSegment._metadata, StateCalcPositionDifferenceOtherSegment._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcPositionDifferenceOtherSegment._metadata, StateCalcPositionDifferenceOtherSegment._set_segment_state_to_use_metadata, value)

    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcPositionDifferenceOtherSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcPositionDifferenceOtherSegment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcPositionDifferenceOtherSegment, [StateCalcPositionDifferenceOtherSegment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5410120896638206049, 17404805778208513193), StateCalcPositionDifferenceOtherSegment)
agcls.AgTypeNameMap["StateCalcPositionDifferenceOtherSegment"] = StateCalcPositionDifferenceOtherSegment

class StateCalcVelocityDifferenceOtherSegment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Velocity Difference Across Segments calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_other_segment_name_method_offset = 1
    _set_other_segment_name_method_offset = 2
    _get_segment_state_to_use_method_offset = 3
    _set_segment_state_to_use_method_offset = 4
    _metadata = {
        "iid_data" : (5761930326505428509, 15079222405094269835),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVelocityDifferenceOtherSegment)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcVelocityDifferenceOtherSegment._metadata, StateCalcVelocityDifferenceOtherSegment._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVelocityDifferenceOtherSegment._metadata, StateCalcVelocityDifferenceOtherSegment._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcVelocityDifferenceOtherSegment._metadata, StateCalcVelocityDifferenceOtherSegment._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcVelocityDifferenceOtherSegment._metadata, StateCalcVelocityDifferenceOtherSegment._set_segment_state_to_use_metadata, value)

    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVelocityDifferenceOtherSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVelocityDifferenceOtherSegment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVelocityDifferenceOtherSegment, [StateCalcVelocityDifferenceOtherSegment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4700414338115361174, 7357519667103594396), StateCalcVelocityDifferenceOtherSegment)
agcls.AgTypeNameMap["StateCalcVelocityDifferenceOtherSegment"] = StateCalcVelocityDifferenceOtherSegment

class StateCalcPositionVelocityDifferenceOtherSegment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Position and Velocity Difference Across Segments calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_other_segment_name_method_offset = 1
    _set_other_segment_name_method_offset = 2
    _get_segment_state_to_use_method_offset = 3
    _set_segment_state_to_use_method_offset = 4
    _metadata = {
        "iid_data" : (5099216661152147837, 12403806086621600668),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcPositionVelocityDifferenceOtherSegment)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcPositionVelocityDifferenceOtherSegment._metadata, StateCalcPositionVelocityDifferenceOtherSegment._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcPositionVelocityDifferenceOtherSegment._metadata, StateCalcPositionVelocityDifferenceOtherSegment._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcPositionVelocityDifferenceOtherSegment._metadata, StateCalcPositionVelocityDifferenceOtherSegment._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcPositionVelocityDifferenceOtherSegment._metadata, StateCalcPositionVelocityDifferenceOtherSegment._set_segment_state_to_use_metadata, value)

    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcPositionVelocityDifferenceOtherSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcPositionVelocityDifferenceOtherSegment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcPositionVelocityDifferenceOtherSegment, [StateCalcPositionVelocityDifferenceOtherSegment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4698031524605327091, 1241434726579484094), StateCalcPositionVelocityDifferenceOtherSegment)
agcls.AgTypeNameMap["StateCalcPositionVelocityDifferenceOtherSegment"] = StateCalcPositionVelocityDifferenceOtherSegment

class StateCalcValueAtSegment(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Value At Segment calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_other_segment_name_method_offset = 3
    _set_other_segment_name_method_offset = 4
    _get_segment_state_to_use_method_offset = 5
    _set_segment_state_to_use_method_offset = 6
    _metadata = {
        "iid_data" : (5685182645245177465, 12446171846639774123),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcValueAtSegment)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._set_calculation_object_name_metadata, value)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcValueAtSegment._metadata, StateCalcValueAtSegment._set_segment_state_to_use_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcValueAtSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcValueAtSegment)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcValueAtSegment, [StateCalcValueAtSegment, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4717001101179136674, 7712842298125538966), StateCalcValueAtSegment)
agcls.AgTypeNameMap["StateCalcValueAtSegment"] = StateCalcValueAtSegment

class StateCalcMaxValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Maximum Value calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5693913850214738875, 7362033195491517325),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMaxValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcMaxValue._metadata, StateCalcMaxValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMaxValue._metadata, StateCalcMaxValue._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMaxValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMaxValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMaxValue, [StateCalcMaxValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5335981867772603023, 14948483817211843495), StateCalcMaxValue)
agcls.AgTypeNameMap["StateCalcMaxValue"] = StateCalcMaxValue

class StateCalcMinValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Minimum Value calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5508979191941518953, 13437319745405890183),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMinValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcMinValue._metadata, StateCalcMinValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMinValue._metadata, StateCalcMinValue._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMinValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMinValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMinValue, [StateCalcMinValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5325867396643517457, 15325837370797593534), StateCalcMinValue)
agcls.AgTypeNameMap["StateCalcMinValue"] = StateCalcMinValue

class StateCalcMeanValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Mean Value calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5071065384386542095, 2074797407162959239),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMeanValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcMeanValue._metadata, StateCalcMeanValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMeanValue._metadata, StateCalcMeanValue._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMeanValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMeanValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMeanValue, [StateCalcMeanValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4892731750122549927, 895807499915618237), StateCalcMeanValue)
agcls.AgTypeNameMap["StateCalcMeanValue"] = StateCalcMeanValue

class StateCalcMedianValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Median Value calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5380204605260779977, 8527191360378932610),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMedianValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcMedianValue._metadata, StateCalcMedianValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMedianValue._metadata, StateCalcMedianValue._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMedianValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMedianValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMedianValue, [StateCalcMedianValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5017390870345423063, 11107553627398305450), StateCalcMedianValue)
agcls.AgTypeNameMap["StateCalcMedianValue"] = StateCalcMedianValue

class StateCalcStandardDeviation(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Standard Deviation calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5109749522595346465, 5943122520799404),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcStandardDeviation)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcStandardDeviation._metadata, StateCalcStandardDeviation._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcStandardDeviation._metadata, StateCalcStandardDeviation._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcStandardDeviation."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcStandardDeviation)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcStandardDeviation, [StateCalcStandardDeviation, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5706630325153378416, 7346312026473310895), StateCalcStandardDeviation)
agcls.AgTypeNameMap["StateCalcStandardDeviation"] = StateCalcStandardDeviation

class StateCalcNegative(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Negative calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _metadata = {
        "iid_data" : (5494223374580793993, 17445090105393654670),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcNegative)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation  object."""
        return self._intf.get_property(StateCalcNegative._metadata, StateCalcNegative._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcNegative._metadata, StateCalcNegative._set_calculation_object_name_metadata, value)

    _property_names[calculation_object_name] = "calculation_object_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcNegative."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcNegative)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcNegative, [StateCalcNegative, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4756880992387727043, 16118258532645794438), StateCalcNegative)
agcls.AgTypeNameMap["StateCalcNegative"] = StateCalcNegative

class StateCalcEccentricity(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Eccentricity calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5132596794288842807, 76886317482222211),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEccentricity)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEccentricity._metadata, StateCalcEccentricity._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEccentricity._metadata, StateCalcEccentricity._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcEccentricity._metadata, StateCalcEccentricity._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcEccentricity._metadata, StateCalcEccentricity._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEccentricity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEccentricity)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEccentricity, [StateCalcEccentricity, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5501682676133367136, 3167489185269360787), StateCalcEccentricity)
agcls.AgTypeNameMap["StateCalcEccentricity"] = StateCalcEccentricity

class StateCalcMeanAnomaly(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a MeanAnomaly calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5078592635508230677, 199917539856335784),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcMeanAnomaly)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcMeanAnomaly._metadata, StateCalcMeanAnomaly._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcMeanAnomaly._metadata, StateCalcMeanAnomaly._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcMeanAnomaly._metadata, StateCalcMeanAnomaly._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcMeanAnomaly._metadata, StateCalcMeanAnomaly._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcMeanAnomaly."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcMeanAnomaly)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcMeanAnomaly, [StateCalcMeanAnomaly, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4892312041291241898, 6574642583384567699), StateCalcMeanAnomaly)
agcls.AgTypeNameMap["StateCalcMeanAnomaly"] = StateCalcMeanAnomaly

class StateCalcRAAN(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RAAN calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5381083598080536156, 9958123801964845187),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRAAN)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcRAAN._metadata, StateCalcRAAN._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRAAN._metadata, StateCalcRAAN._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcRAAN._metadata, StateCalcRAAN._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRAAN._metadata, StateCalcRAAN._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRAAN."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRAAN)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRAAN, [StateCalcRAAN, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5405103448896378970, 4337604741307927470), StateCalcRAAN)
agcls.AgTypeNameMap["StateCalcRAAN"] = StateCalcRAAN

class BDotRCalc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a BDotR calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_body_name_method_offset = 1
    _set_target_body_name_method_offset = 2
    _get_reference_vector_name_method_offset = 3
    _set_reference_vector_name_method_offset = 4
    _metadata = {
        "iid_data" : (4788843118955322831, 4556250982297463961),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BDotRCalc)

    _get_target_body_name_metadata = { "offset" : _get_target_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_body_name(self) -> str:
        """Get or set the target body for B-plane computation."""
        return self._intf.get_property(BDotRCalc._metadata, BDotRCalc._get_target_body_name_metadata)

    _set_target_body_name_metadata = { "offset" : _set_target_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_body_name.setter
    def target_body_name(self, value:str) -> None:
        return self._intf.set_property(BDotRCalc._metadata, BDotRCalc._set_target_body_name_metadata, value)

    _get_reference_vector_name_metadata = { "offset" : _get_reference_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_vector_name(self) -> str:
        """Get or set the reference vector to use to define the B-plane."""
        return self._intf.get_property(BDotRCalc._metadata, BDotRCalc._get_reference_vector_name_metadata)

    _set_reference_vector_name_metadata = { "offset" : _set_reference_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_vector_name.setter
    def reference_vector_name(self, value:str) -> None:
        return self._intf.set_property(BDotRCalc._metadata, BDotRCalc._set_reference_vector_name_metadata, value)

    _property_names[target_body_name] = "target_body_name"
    _property_names[reference_vector_name] = "reference_vector_name"

    def __init__(self, source_object=None):
        """Construct an object of type BDotRCalc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BDotRCalc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BDotRCalc, [BDotRCalc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4764853868400043048, 18187604709841805988), BDotRCalc)
agcls.AgTypeNameMap["BDotRCalc"] = BDotRCalc

class BDotTCalc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a BDotT calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_body_name_method_offset = 1
    _set_target_body_name_method_offset = 2
    _get_reference_vector_name_method_offset = 3
    _set_reference_vector_name_method_offset = 4
    _metadata = {
        "iid_data" : (4618960820775064092, 18231298778754049955),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BDotTCalc)

    _get_target_body_name_metadata = { "offset" : _get_target_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_body_name(self) -> str:
        """Get or set the target body for B-plane computation."""
        return self._intf.get_property(BDotTCalc._metadata, BDotTCalc._get_target_body_name_metadata)

    _set_target_body_name_metadata = { "offset" : _set_target_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_body_name.setter
    def target_body_name(self, value:str) -> None:
        return self._intf.set_property(BDotTCalc._metadata, BDotTCalc._set_target_body_name_metadata, value)

    _get_reference_vector_name_metadata = { "offset" : _get_reference_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_vector_name(self) -> str:
        """Get or set the reference vector to use to define the B-plane."""
        return self._intf.get_property(BDotTCalc._metadata, BDotTCalc._get_reference_vector_name_metadata)

    _set_reference_vector_name_metadata = { "offset" : _set_reference_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_vector_name.setter
    def reference_vector_name(self, value:str) -> None:
        return self._intf.set_property(BDotTCalc._metadata, BDotTCalc._set_reference_vector_name_metadata, value)

    _property_names[target_body_name] = "target_body_name"
    _property_names[reference_vector_name] = "reference_vector_name"

    def __init__(self, source_object=None):
        """Construct an object of type BDotTCalc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BDotTCalc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BDotTCalc, [BDotTCalc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4890798717385089098, 6364035963206107010), BDotTCalc)
agcls.AgTypeNameMap["BDotTCalc"] = BDotTCalc

class BMagnitudeCalc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a BMagnitude calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_body_name_method_offset = 1
    _set_target_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4647292914321785240, 13934252389565936309),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BMagnitudeCalc)

    _get_target_body_name_metadata = { "offset" : _get_target_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_body_name(self) -> str:
        """Get or set the target body for B-plane computation."""
        return self._intf.get_property(BMagnitudeCalc._metadata, BMagnitudeCalc._get_target_body_name_metadata)

    _set_target_body_name_metadata = { "offset" : _set_target_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_body_name.setter
    def target_body_name(self, value:str) -> None:
        return self._intf.set_property(BMagnitudeCalc._metadata, BMagnitudeCalc._set_target_body_name_metadata, value)

    _property_names[target_body_name] = "target_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type BMagnitudeCalc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BMagnitudeCalc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BMagnitudeCalc, [BMagnitudeCalc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5134716065589206218, 7480759871545627779), BMagnitudeCalc)
agcls.AgTypeNameMap["BMagnitudeCalc"] = BMagnitudeCalc

class BThetaCalc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a BTheta calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_body_name_method_offset = 1
    _set_target_body_name_method_offset = 2
    _get_reference_vector_name_method_offset = 3
    _set_reference_vector_name_method_offset = 4
    _metadata = {
        "iid_data" : (5007774658254643496, 13271531197844527280),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BThetaCalc)

    _get_target_body_name_metadata = { "offset" : _get_target_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_body_name(self) -> str:
        """Get or set the target body for B-plane computation."""
        return self._intf.get_property(BThetaCalc._metadata, BThetaCalc._get_target_body_name_metadata)

    _set_target_body_name_metadata = { "offset" : _set_target_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_body_name.setter
    def target_body_name(self, value:str) -> None:
        return self._intf.set_property(BThetaCalc._metadata, BThetaCalc._set_target_body_name_metadata, value)

    _get_reference_vector_name_metadata = { "offset" : _get_reference_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_vector_name(self) -> str:
        """Get or set the reference vector to use to define the B-plane."""
        return self._intf.get_property(BThetaCalc._metadata, BThetaCalc._get_reference_vector_name_metadata)

    _set_reference_vector_name_metadata = { "offset" : _set_reference_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_vector_name.setter
    def reference_vector_name(self, value:str) -> None:
        return self._intf.set_property(BThetaCalc._metadata, BThetaCalc._set_reference_vector_name_metadata, value)

    _property_names[target_body_name] = "target_body_name"
    _property_names[reference_vector_name] = "reference_vector_name"

    def __init__(self, source_object=None):
        """Construct an object of type BThetaCalc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BThetaCalc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BThetaCalc, [BThetaCalc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5596689204320332812, 4811551774192881053), BThetaCalc)
agcls.AgTypeNameMap["BThetaCalc"] = BThetaCalc

class StateCalcDeltaDec(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Delta Declination calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_type_method_offset = 3
    _set_reference_type_method_offset = 4
    _get_reference_body_method_offset = 5
    _set_reference_body_method_offset = 6
    _metadata = {
        "iid_data" : (5290013676220494388, 9903183221335827391),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDeltaDec)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._set_central_body_name_metadata, value)

    _get_reference_type_metadata = { "offset" : _get_reference_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectCentralBodyReference),) }
    @property
    def reference_type(self) -> "CalculationObjectCentralBodyReference":
        """Get or set the central body's reference type."""
        return self._intf.get_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._get_reference_type_metadata)

    _set_reference_type_metadata = { "offset" : _set_reference_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectCentralBodyReference),) }
    @reference_type.setter
    def reference_type(self, value:"CalculationObjectCentralBodyReference") -> None:
        return self._intf.set_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._set_reference_type_metadata, value)

    _get_reference_body_metadata = { "offset" : _get_reference_body_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_body(self) -> str:
        """Get or set the reference body of the component. Read only when the ReferenceType is eVACalcObjectCentralBodyReferenceParent."""
        return self._intf.get_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._get_reference_body_metadata)

    _set_reference_body_metadata = { "offset" : _set_reference_body_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_body.setter
    def reference_body(self, value:str) -> None:
        return self._intf.set_property(StateCalcDeltaDec._metadata, StateCalcDeltaDec._set_reference_body_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_type] = "reference_type"
    _property_names[reference_body] = "reference_body"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDeltaDec."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDeltaDec)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDeltaDec, [StateCalcDeltaDec, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4742177159243228554, 9768761161646057663), StateCalcDeltaDec)
agcls.AgTypeNameMap["StateCalcDeltaDec"] = StateCalcDeltaDec

class StateCalcDeltaRA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Delta Right Asc calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_type_method_offset = 3
    _set_reference_type_method_offset = 4
    _get_reference_body_method_offset = 5
    _set_reference_body_method_offset = 6
    _metadata = {
        "iid_data" : (4868101605846675839, 11443682580650707381),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDeltaRA)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._set_central_body_name_metadata, value)

    _get_reference_type_metadata = { "offset" : _get_reference_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectCentralBodyReference),) }
    @property
    def reference_type(self) -> "CalculationObjectCentralBodyReference":
        """Get or set the central body's reference type."""
        return self._intf.get_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._get_reference_type_metadata)

    _set_reference_type_metadata = { "offset" : _set_reference_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectCentralBodyReference),) }
    @reference_type.setter
    def reference_type(self, value:"CalculationObjectCentralBodyReference") -> None:
        return self._intf.set_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._set_reference_type_metadata, value)

    _get_reference_body_metadata = { "offset" : _get_reference_body_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_body(self) -> str:
        """Get or set the reference body of the component. Read only when the ReferenceType is eVACalcObjectCentralBodyReferenceParent."""
        return self._intf.get_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._get_reference_body_metadata)

    _set_reference_body_metadata = { "offset" : _set_reference_body_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_body.setter
    def reference_body(self, value:str) -> None:
        return self._intf.set_property(StateCalcDeltaRA._metadata, StateCalcDeltaRA._set_reference_body_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_type] = "reference_type"
    _property_names[reference_body] = "reference_body"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDeltaRA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDeltaRA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDeltaRA, [StateCalcDeltaRA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5688767206261697070, 361885936146426807), StateCalcDeltaRA)
agcls.AgTypeNameMap["StateCalcDeltaRA"] = StateCalcDeltaRA

class StateCalcBetaAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Beta Angle calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5491371553853873553, 16290909826073259189),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcBetaAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcBetaAngle._metadata, StateCalcBetaAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcBetaAngle._metadata, StateCalcBetaAngle._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcBetaAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcBetaAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcBetaAngle, [StateCalcBetaAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5083630350938674598, 2520004052854407858), StateCalcBetaAngle)
agcls.AgTypeNameMap["StateCalcBetaAngle"] = StateCalcBetaAngle

class StateCalcLocalApparentSolarLon(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Local Apparent Solar Longitude calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (4710959404518107307, 6957049819451085726),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcLocalApparentSolarLon)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcLocalApparentSolarLon._metadata, StateCalcLocalApparentSolarLon._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcLocalApparentSolarLon._metadata, StateCalcLocalApparentSolarLon._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcLocalApparentSolarLon."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcLocalApparentSolarLon)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcLocalApparentSolarLon, [StateCalcLocalApparentSolarLon, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4935767401018702893, 4837353967401391754), StateCalcLocalApparentSolarLon)
agcls.AgTypeNameMap["StateCalcLocalApparentSolarLon"] = StateCalcLocalApparentSolarLon

class StateCalcLonOfPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Longitude of Periapsis calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5342377182843817648, 17338033931095343495),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcLonOfPeriapsis)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcLonOfPeriapsis._metadata, StateCalcLonOfPeriapsis._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcLonOfPeriapsis._metadata, StateCalcLonOfPeriapsis._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcLonOfPeriapsis._metadata, StateCalcLonOfPeriapsis._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcLonOfPeriapsis._metadata, StateCalcLonOfPeriapsis._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcLonOfPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcLonOfPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcLonOfPeriapsis, [StateCalcLonOfPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5390362933097802402, 15121927569055714719), StateCalcLonOfPeriapsis)
agcls.AgTypeNameMap["StateCalcLonOfPeriapsis"] = StateCalcLonOfPeriapsis

class StateCalcOrbitStateValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Orbit State Value calculation object."""

    _num_methods = 20
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_input_coord_system_name_method_offset = 3
    _set_input_coord_system_name_method_offset = 4
    _get_x_method_offset = 5
    _set_x_method_offset = 6
    _get_y_method_offset = 7
    _set_y_method_offset = 8
    _get_z_method_offset = 9
    _set_z_method_offset = 10
    _get_vx_method_offset = 11
    _set_vx_method_offset = 12
    _get_vy_method_offset = 13
    _set_vy_method_offset = 14
    _get_vz_method_offset = 15
    _set_vz_method_offset = 16
    _enable_control_parameter_method_offset = 17
    _disable_control_parameter_method_offset = 18
    _is_control_parameter_enabled_method_offset = 19
    _get_control_parameters_available_method_offset = 20
    _metadata = {
        "iid_data" : (5571605285225794087, 11521766938948305318),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOrbitStateValue)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_calculation_object_name_metadata, value)

    _get_input_coord_system_name_metadata = { "offset" : _get_input_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def input_coord_system_name(self) -> str:
        """Get or set the coordinate system of the input state."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_input_coord_system_name_metadata)

    _set_input_coord_system_name_metadata = { "offset" : _set_input_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @input_coord_system_name.setter
    def input_coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_input_coord_system_name_metadata, value)

    _get_x_metadata = { "offset" : _get_x_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def x(self) -> typing.Any:
        """Get or set the x position component. Uses Distance Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_x_metadata)

    _set_x_metadata = { "offset" : _set_x_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @x.setter
    def x(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_x_metadata, value)

    _get_y_metadata = { "offset" : _get_y_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def y(self) -> typing.Any:
        """Get or set the y position component. Uses Distance Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_y_metadata)

    _set_y_metadata = { "offset" : _set_y_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @y.setter
    def y(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_y_metadata, value)

    _get_z_metadata = { "offset" : _get_z_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def z(self) -> typing.Any:
        """Get or set the z position component. Uses Distance Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_z_metadata)

    _set_z_metadata = { "offset" : _set_z_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @z.setter
    def z(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_z_metadata, value)

    _get_vx_metadata = { "offset" : _get_vx_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def vx(self) -> typing.Any:
        """Get or set the x velocity component. Uses Rate Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_vx_metadata)

    _set_vx_metadata = { "offset" : _set_vx_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @vx.setter
    def vx(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_vx_metadata, value)

    _get_vy_metadata = { "offset" : _get_vy_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def vy(self) -> typing.Any:
        """Get or set the y velocity component. Uses Rate Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_vy_metadata)

    _set_vy_metadata = { "offset" : _set_vy_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @vy.setter
    def vy(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_vy_metadata, value)

    _get_vz_metadata = { "offset" : _get_vz_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def vz(self) -> typing.Any:
        """Get or set the z velocity component. Uses Rate Dimension."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_vz_metadata)

    _set_vz_metadata = { "offset" : _set_vz_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @vz.setter
    def vz(self, value:typing.Any) -> None:
        return self._intf.set_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._set_vz_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlOrbitStateValue),) }
    def enable_control_parameter(self, param:"ControlOrbitStateValue") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlOrbitStateValue),) }
    def disable_control_parameter(self, param:"ControlOrbitStateValue") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlOrbitStateValue), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlOrbitStateValue") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(StateCalcOrbitStateValue._metadata, StateCalcOrbitStateValue._get_control_parameters_available_metadata)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[input_coord_system_name] = "input_coord_system_name"
    _property_names[x] = "x"
    _property_names[y] = "y"
    _property_names[z] = "z"
    _property_names[vx] = "vx"
    _property_names[vy] = "vy"
    _property_names[vz] = "vz"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOrbitStateValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOrbitStateValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOrbitStateValue, [StateCalcOrbitStateValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5660476195838860374, 7373399722690661047), StateCalcOrbitStateValue)
agcls.AgTypeNameMap["StateCalcOrbitStateValue"] = StateCalcOrbitStateValue

class StateCalcSignedEccentricity(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a SignedEccentricity calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5758428425739901521, 3466807939090115987),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSignedEccentricity)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcSignedEccentricity._metadata, StateCalcSignedEccentricity._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSignedEccentricity._metadata, StateCalcSignedEccentricity._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcSignedEccentricity._metadata, StateCalcSignedEccentricity._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcSignedEccentricity._metadata, StateCalcSignedEccentricity._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSignedEccentricity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSignedEccentricity)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSignedEccentricity, [StateCalcSignedEccentricity, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5191176072478866871, 8134725428167828098), StateCalcSignedEccentricity)
agcls.AgTypeNameMap["StateCalcSignedEccentricity"] = StateCalcSignedEccentricity

class StateCalcInclination(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Inclination calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5481867825683167402, 11775092398994058639),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInclination)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcInclination._metadata, StateCalcInclination._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInclination._metadata, StateCalcInclination._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcInclination._metadata, StateCalcInclination._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcInclination._metadata, StateCalcInclination._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInclination."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInclination)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInclination, [StateCalcInclination, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5120832088065050933, 16106417628964848268), StateCalcInclination)
agcls.AgTypeNameMap["StateCalcInclination"] = StateCalcInclination

class StateCalcTrueLon(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a True Longitude calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (5283503522563827653, 1949981448141737121),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcTrueLon)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcTrueLon._metadata, StateCalcTrueLon._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcTrueLon._metadata, StateCalcTrueLon._set_coord_system_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type."""
        return self._intf.get_property(StateCalcTrueLon._metadata, StateCalcTrueLon._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcTrueLon._metadata, StateCalcTrueLon._set_element_type_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcTrueLon."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcTrueLon)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcTrueLon, [StateCalcTrueLon, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4659594054530973860, 10956547747767183491), StateCalcTrueLon)
agcls.AgTypeNameMap["StateCalcTrueLon"] = StateCalcTrueLon

class StateCalcPower(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Power calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_power_source_name_method_offset = 1
    _set_power_source_name_method_offset = 2
    _metadata = {
        "iid_data" : (5613531350273265511, 6381946946512684674),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcPower)

    _get_power_source_name_metadata = { "offset" : _get_power_source_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def power_source_name(self) -> str:
        """Get or set the power source."""
        return self._intf.get_property(StateCalcPower._metadata, StateCalcPower._get_power_source_name_metadata)

    _set_power_source_name_metadata = { "offset" : _set_power_source_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @power_source_name.setter
    def power_source_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcPower._metadata, StateCalcPower._set_power_source_name_metadata, value)

    _property_names[power_source_name] = "power_source_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcPower."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcPower)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcPower, [StateCalcPower, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4956417164732171081, 9430265978231260054), StateCalcPower)
agcls.AgTypeNameMap["StateCalcPower"] = StateCalcPower

class StateCalcRelativeMotion(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Relative Motion calculation object."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_origin_at_chief_method_offset = 3
    _set_origin_at_chief_method_offset = 4
    _get_reference_selection_method_offset = 5
    _set_reference_selection_method_offset = 6
    _get_reference_method_offset = 7
    _metadata = {
        "iid_data" : (5002195614498734697, 15794600710772473250),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativeMotion)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._set_central_body_name_metadata, value)

    _get_origin_at_chief_metadata = { "offset" : _get_origin_at_chief_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def origin_at_chief(self) -> bool:
        """True if the origin is at the reference satellite, false if the origin is at the current satellite."""
        return self._intf.get_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._get_origin_at_chief_metadata)

    _set_origin_at_chief_metadata = { "offset" : _set_origin_at_chief_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @origin_at_chief.setter
    def origin_at_chief(self, value:bool) -> None:
        return self._intf.set_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._set_origin_at_chief_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativeMotion._metadata, StateCalcRelativeMotion._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[origin_at_chief] = "origin_at_chief"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativeMotion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativeMotion)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativeMotion, [StateCalcRelativeMotion, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4661395227350171712, 3732445803166842778), StateCalcRelativeMotion)
agcls.AgTypeNameMap["StateCalcRelativeMotion"] = StateCalcRelativeMotion

class StateCalcSolarBetaAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Solar Beta Angle calculation object."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_orbit_plane_source_method_offset = 3
    _set_orbit_plane_source_method_offset = 4
    _get_element_type_method_offset = 5
    _set_element_type_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _get_sun_position_method_offset = 10
    _set_sun_position_method_offset = 11
    _get_sign_convention_method_offset = 12
    _set_sign_convention_method_offset = 13
    _metadata = {
        "iid_data" : (5398438437428592507, 2650543482928872872),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSolarBetaAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_central_body_name_metadata, value)

    _get_orbit_plane_source_metadata = { "offset" : _get_orbit_plane_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @property
    def orbit_plane_source(self) -> "CalculationObjectOrbitPlaneSource":
        """Selection of the satellite that will generate the orbit plane."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_orbit_plane_source_metadata)

    _set_orbit_plane_source_metadata = { "offset" : _set_orbit_plane_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @orbit_plane_source.setter
    def orbit_plane_source(self, value:"CalculationObjectOrbitPlaneSource") -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_orbit_plane_source_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_element_type_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_reference_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectSunPosition),) }
    @property
    def sun_position(self) -> "CalculationObjectSunPosition":
        """Get or set the type of the Sun location."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectSunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"CalculationObjectSunPosition") -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_sun_position_metadata, value)

    _get_sign_convention_metadata = { "offset" : _get_sign_convention_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @property
    def sign_convention(self) -> "CalculationObjectAngleSign":
        """Get or set the sign of the angle when the relative position has a positive component along the orbit normal."""
        return self._intf.get_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._get_sign_convention_metadata)

    _set_sign_convention_metadata = { "offset" : _set_sign_convention_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @sign_convention.setter
    def sign_convention(self, value:"CalculationObjectAngleSign") -> None:
        return self._intf.set_property(StateCalcSolarBetaAngle._metadata, StateCalcSolarBetaAngle._set_sign_convention_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[orbit_plane_source] = "orbit_plane_source"
    _property_names[element_type] = "element_type"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"
    _property_names[sun_position] = "sun_position"
    _property_names[sign_convention] = "sign_convention"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSolarBetaAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSolarBetaAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSolarBetaAngle, [StateCalcSolarBetaAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5077135050113269633, 9161741470567867320), StateCalcSolarBetaAngle)
agcls.AgTypeNameMap["StateCalcSolarBetaAngle"] = StateCalcSolarBetaAngle

class StateCalcSolarInPlaneAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Solar In Plane Angle calculation object."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_orbit_plane_source_method_offset = 3
    _set_orbit_plane_source_method_offset = 4
    _get_element_type_method_offset = 5
    _set_element_type_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _get_sun_position_method_offset = 10
    _set_sun_position_method_offset = 11
    _get_counter_clockwise_rotation_method_offset = 12
    _set_counter_clockwise_rotation_method_offset = 13
    _get_reference_direction_method_offset = 14
    _set_reference_direction_method_offset = 15
    _metadata = {
        "iid_data" : (5525853297664348995, 13048979656566293681),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSolarInPlaneAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_central_body_name_metadata, value)

    _get_orbit_plane_source_metadata = { "offset" : _get_orbit_plane_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @property
    def orbit_plane_source(self) -> "CalculationObjectOrbitPlaneSource":
        """Selection of the satellite that will generate the orbit plane."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_orbit_plane_source_metadata)

    _set_orbit_plane_source_metadata = { "offset" : _set_orbit_plane_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @orbit_plane_source.setter
    def orbit_plane_source(self, value:"CalculationObjectOrbitPlaneSource") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_orbit_plane_source_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_element_type_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_reference_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectSunPosition),) }
    @property
    def sun_position(self) -> "CalculationObjectSunPosition":
        """Get or set the type of the Sun location."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectSunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"CalculationObjectSunPosition") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_sun_position_metadata, value)

    _get_counter_clockwise_rotation_metadata = { "offset" : _get_counter_clockwise_rotation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @property
    def counter_clockwise_rotation(self) -> "CalculationObjectAngleSign":
        """Set sign of the angle for counterclockwise rotation about orbit normal."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_counter_clockwise_rotation_metadata)

    _set_counter_clockwise_rotation_metadata = { "offset" : _set_counter_clockwise_rotation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @counter_clockwise_rotation.setter
    def counter_clockwise_rotation(self, value:"CalculationObjectAngleSign") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_counter_clockwise_rotation_metadata, value)

    _get_reference_direction_metadata = { "offset" : _get_reference_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceDirection),) }
    @property
    def reference_direction(self) -> "CalculationObjectReferenceDirection":
        """Direction that establishes the zero value when projected into the orbit plane."""
        return self._intf.get_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._get_reference_direction_metadata)

    _set_reference_direction_metadata = { "offset" : _set_reference_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceDirection),) }
    @reference_direction.setter
    def reference_direction(self, value:"CalculationObjectReferenceDirection") -> None:
        return self._intf.set_property(StateCalcSolarInPlaneAngle._metadata, StateCalcSolarInPlaneAngle._set_reference_direction_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[orbit_plane_source] = "orbit_plane_source"
    _property_names[element_type] = "element_type"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"
    _property_names[sun_position] = "sun_position"
    _property_names[counter_clockwise_rotation] = "counter_clockwise_rotation"
    _property_names[reference_direction] = "reference_direction"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSolarInPlaneAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSolarInPlaneAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSolarInPlaneAngle, [StateCalcSolarInPlaneAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4748871734981473687, 2552028746492672439), StateCalcSolarInPlaneAngle)
agcls.AgTypeNameMap["StateCalcSolarInPlaneAngle"] = StateCalcSolarInPlaneAngle

class StateCalcRelativePositionDecAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Relative Position Declination Angle calculation object."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_orbit_plane_source_method_offset = 3
    _set_orbit_plane_source_method_offset = 4
    _get_element_type_method_offset = 5
    _set_element_type_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _get_relative_position_type_method_offset = 10
    _set_relative_position_type_method_offset = 11
    _get_sign_convention_method_offset = 12
    _set_sign_convention_method_offset = 13
    _metadata = {
        "iid_data" : (5238851579005461793, 16812563106976176295),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativePositionDecAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_central_body_name_metadata, value)

    _get_orbit_plane_source_metadata = { "offset" : _get_orbit_plane_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @property
    def orbit_plane_source(self) -> "CalculationObjectOrbitPlaneSource":
        """Selection of the satellite that will generate the orbit plane."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_orbit_plane_source_metadata)

    _set_orbit_plane_source_metadata = { "offset" : _set_orbit_plane_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @orbit_plane_source.setter
    def orbit_plane_source(self, value:"CalculationObjectOrbitPlaneSource") -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_orbit_plane_source_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_element_type_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_reference_metadata)

    _get_relative_position_type_metadata = { "offset" : _get_relative_position_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectRelativePosition),) }
    @property
    def relative_position_type(self) -> "CalculationObjectRelativePosition":
        """Get or set the type of the relative position."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_relative_position_type_metadata)

    _set_relative_position_type_metadata = { "offset" : _set_relative_position_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectRelativePosition),) }
    @relative_position_type.setter
    def relative_position_type(self, value:"CalculationObjectRelativePosition") -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_relative_position_type_metadata, value)

    _get_sign_convention_metadata = { "offset" : _get_sign_convention_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @property
    def sign_convention(self) -> "CalculationObjectAngleSign":
        """Get or set the sign of the angle when the relative position has a positive component along the orbit normal."""
        return self._intf.get_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._get_sign_convention_metadata)

    _set_sign_convention_metadata = { "offset" : _set_sign_convention_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @sign_convention.setter
    def sign_convention(self, value:"CalculationObjectAngleSign") -> None:
        return self._intf.set_property(StateCalcRelativePositionDecAngle._metadata, StateCalcRelativePositionDecAngle._set_sign_convention_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[orbit_plane_source] = "orbit_plane_source"
    _property_names[element_type] = "element_type"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"
    _property_names[relative_position_type] = "relative_position_type"
    _property_names[sign_convention] = "sign_convention"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativePositionDecAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativePositionDecAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativePositionDecAngle, [StateCalcRelativePositionDecAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4885866484788968886, 3882329827102669962), StateCalcRelativePositionDecAngle)
agcls.AgTypeNameMap["StateCalcRelativePositionDecAngle"] = StateCalcRelativePositionDecAngle

class StateCalcRelativePositionInPlaneAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Relative Position In Plane Angle calculation object."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_orbit_plane_source_method_offset = 3
    _set_orbit_plane_source_method_offset = 4
    _get_element_type_method_offset = 5
    _set_element_type_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _get_relative_position_type_method_offset = 10
    _set_relative_position_type_method_offset = 11
    _get_counter_clockwise_rotation_method_offset = 12
    _set_counter_clockwise_rotation_method_offset = 13
    _get_reference_direction_method_offset = 14
    _set_reference_direction_method_offset = 15
    _metadata = {
        "iid_data" : (5276106845718310985, 15169476527219437464),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativePositionInPlaneAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_central_body_name_metadata, value)

    _get_orbit_plane_source_metadata = { "offset" : _get_orbit_plane_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @property
    def orbit_plane_source(self) -> "CalculationObjectOrbitPlaneSource":
        """Selection of the satellite that will generate the orbit plane."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_orbit_plane_source_metadata)

    _set_orbit_plane_source_metadata = { "offset" : _set_orbit_plane_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectOrbitPlaneSource),) }
    @orbit_plane_source.setter
    def orbit_plane_source(self, value:"CalculationObjectOrbitPlaneSource") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_orbit_plane_source_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_element_type_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_reference_metadata)

    _get_relative_position_type_metadata = { "offset" : _get_relative_position_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectRelativePosition),) }
    @property
    def relative_position_type(self) -> "CalculationObjectRelativePosition":
        """Get or set the type of the relative position."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_relative_position_type_metadata)

    _set_relative_position_type_metadata = { "offset" : _set_relative_position_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectRelativePosition),) }
    @relative_position_type.setter
    def relative_position_type(self, value:"CalculationObjectRelativePosition") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_relative_position_type_metadata, value)

    _get_counter_clockwise_rotation_metadata = { "offset" : _get_counter_clockwise_rotation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @property
    def counter_clockwise_rotation(self) -> "CalculationObjectAngleSign":
        """Set sign of the angle for counterclockwise rotation about orbit normal."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_counter_clockwise_rotation_metadata)

    _set_counter_clockwise_rotation_metadata = { "offset" : _set_counter_clockwise_rotation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @counter_clockwise_rotation.setter
    def counter_clockwise_rotation(self, value:"CalculationObjectAngleSign") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_counter_clockwise_rotation_metadata, value)

    _get_reference_direction_metadata = { "offset" : _get_reference_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceDirection),) }
    @property
    def reference_direction(self) -> "CalculationObjectReferenceDirection":
        """Direction that establishes the zero value when projected into the orbit plane."""
        return self._intf.get_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._get_reference_direction_metadata)

    _set_reference_direction_metadata = { "offset" : _set_reference_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceDirection),) }
    @reference_direction.setter
    def reference_direction(self, value:"CalculationObjectReferenceDirection") -> None:
        return self._intf.set_property(StateCalcRelativePositionInPlaneAngle._metadata, StateCalcRelativePositionInPlaneAngle._set_reference_direction_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[orbit_plane_source] = "orbit_plane_source"
    _property_names[element_type] = "element_type"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"
    _property_names[relative_position_type] = "relative_position_type"
    _property_names[counter_clockwise_rotation] = "counter_clockwise_rotation"
    _property_names[reference_direction] = "reference_direction"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativePositionInPlaneAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativePositionInPlaneAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativePositionInPlaneAngle, [StateCalcRelativePositionInPlaneAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5210025623232990293, 477647256645406897), StateCalcRelativePositionInPlaneAngle)
agcls.AgTypeNameMap["StateCalcRelativePositionInPlaneAngle"] = StateCalcRelativePositionInPlaneAngle

class StateCalcRelativeInclination(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Relative Inclination Angle calculation object."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_satellite_orbit_normal_type_method_offset = 3
    _set_satellite_orbit_normal_type_method_offset = 4
    _get_reference_satellite_orbit_normal_type_method_offset = 5
    _set_reference_satellite_orbit_normal_type_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _metadata = {
        "iid_data" : (5759991403051064866, 13962207682969580418),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRelativeInclination)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._set_central_body_name_metadata, value)

    _get_satellite_orbit_normal_type_metadata = { "offset" : _get_satellite_orbit_normal_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def satellite_orbit_normal_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements for describing the orbit plane."""
        return self._intf.get_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._get_satellite_orbit_normal_type_metadata)

    _set_satellite_orbit_normal_type_metadata = { "offset" : _set_satellite_orbit_normal_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @satellite_orbit_normal_type.setter
    def satellite_orbit_normal_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._set_satellite_orbit_normal_type_metadata, value)

    _get_reference_satellite_orbit_normal_type_metadata = { "offset" : _get_reference_satellite_orbit_normal_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def reference_satellite_orbit_normal_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements for describing the orbit plane."""
        return self._intf.get_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._get_reference_satellite_orbit_normal_type_metadata)

    _set_reference_satellite_orbit_normal_type_metadata = { "offset" : _set_reference_satellite_orbit_normal_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @reference_satellite_orbit_normal_type.setter
    def reference_satellite_orbit_normal_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._set_reference_satellite_orbit_normal_type_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcRelativeInclination._metadata, StateCalcRelativeInclination._get_reference_metadata)

    _property_names[central_body_name] = "central_body_name"
    _property_names[satellite_orbit_normal_type] = "satellite_orbit_normal_type"
    _property_names[reference_satellite_orbit_normal_type] = "reference_satellite_orbit_normal_type"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRelativeInclination."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRelativeInclination)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRelativeInclination, [StateCalcRelativeInclination, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4783257135833872479, 4009038032584982670), StateCalcRelativeInclination)
agcls.AgTypeNameMap["StateCalcRelativeInclination"] = StateCalcRelativeInclination

class StateCalcCurvilinearRelativeMotion(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for Curvilinear Relative Motion  calculation object."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_ellipse_method_offset = 3
    _set_reference_ellipse_method_offset = 4
    _get_location_source_method_offset = 5
    _set_location_source_method_offset = 6
    _get_reference_selection_method_offset = 7
    _set_reference_selection_method_offset = 8
    _get_reference_method_offset = 9
    _get_element_type_method_offset = 10
    _set_element_type_method_offset = 11
    _get_sign_convention_method_offset = 12
    _set_sign_convention_method_offset = 13
    _metadata = {
        "iid_data" : (5275245114054728959, 566377476357571002),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCurvilinearRelativeMotion)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_central_body_name_metadata, value)

    _get_reference_ellipse_metadata = { "offset" : _get_reference_ellipse_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceEllipse),) }
    @property
    def reference_ellipse(self) -> "CalculationObjectReferenceEllipse":
        """Selection of the satellite orbit that is used as the reference ellipse."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_reference_ellipse_metadata)

    _set_reference_ellipse_metadata = { "offset" : _set_reference_ellipse_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReferenceEllipse),) }
    @reference_ellipse.setter
    def reference_ellipse(self, value:"CalculationObjectReferenceEllipse") -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_reference_ellipse_metadata, value)

    _get_location_source_metadata = { "offset" : _get_location_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectLocationSource),) }
    @property
    def location_source(self) -> "CalculationObjectLocationSource":
        """Selection of the satellite whose location is being reported with respect to the reference ellipse."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_location_source_metadata)

    _set_location_source_metadata = { "offset" : _set_location_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectLocationSource),) }
    @location_source.setter
    def location_source(self, value:"CalculationObjectLocationSource") -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_location_source_metadata, value)

    _get_reference_selection_metadata = { "offset" : _get_reference_selection_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @property
    def reference_selection(self) -> "CalculationObjectReference":
        """Get or set the reference object selection."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_reference_selection_metadata)

    _set_reference_selection_metadata = { "offset" : _set_reference_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectReference),) }
    @reference_selection.setter
    def reference_selection(self, value:"CalculationObjectReference") -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_reference_selection_metadata, value)

    _get_reference_metadata = { "offset" : _get_reference_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference(self) -> "ILinkToObject":
        """Get the reference object."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_reference_metadata)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Choice of osculating or mean elements."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_element_type_metadata, value)

    _get_sign_convention_metadata = { "offset" : _get_sign_convention_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @property
    def sign_convention(self) -> "CalculationObjectAngleSign":
        """Get or set the sign of the angle when the relative position has a positive component along the orbit normal."""
        return self._intf.get_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._get_sign_convention_metadata)

    _set_sign_convention_metadata = { "offset" : _set_sign_convention_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectAngleSign),) }
    @sign_convention.setter
    def sign_convention(self, value:"CalculationObjectAngleSign") -> None:
        return self._intf.set_property(StateCalcCurvilinearRelativeMotion._metadata, StateCalcCurvilinearRelativeMotion._set_sign_convention_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_ellipse] = "reference_ellipse"
    _property_names[location_source] = "location_source"
    _property_names[reference_selection] = "reference_selection"
    _property_names[reference] = "reference"
    _property_names[element_type] = "element_type"
    _property_names[sign_convention] = "sign_convention"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCurvilinearRelativeMotion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCurvilinearRelativeMotion)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCurvilinearRelativeMotion, [StateCalcCurvilinearRelativeMotion, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5266012728748371250, 3853977684437634452), StateCalcCurvilinearRelativeMotion)
agcls.AgTypeNameMap["StateCalcCurvilinearRelativeMotion"] = StateCalcCurvilinearRelativeMotion

class StateCalcCustomFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Custom Function calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reset_function_name_method_offset = 1
    _set_reset_function_name_method_offset = 2
    _get_eval_function_name_method_offset = 3
    _set_eval_function_name_method_offset = 4
    _get_unit_dimension_method_offset = 5
    _set_unit_dimension_method_offset = 6
    _metadata = {
        "iid_data" : (5238230135416801421, 14434745392186350476),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCustomFunction)

    _get_reset_function_name_metadata = { "offset" : _get_reset_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reset_function_name(self) -> str:
        """Get or set the custom function called before computing, before each segment runs, and before reporting."""
        return self._intf.get_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._get_reset_function_name_metadata)

    _set_reset_function_name_metadata = { "offset" : _set_reset_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reset_function_name.setter
    def reset_function_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._set_reset_function_name_metadata, value)

    _get_eval_function_name_metadata = { "offset" : _get_eval_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def eval_function_name(self) -> str:
        """Get or set the custom function used to calculate this object's value."""
        return self._intf.get_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._get_eval_function_name_metadata)

    _set_eval_function_name_metadata = { "offset" : _set_eval_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @eval_function_name.setter
    def eval_function_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._set_eval_function_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcCustomFunction._metadata, StateCalcCustomFunction._set_unit_dimension_metadata, value)

    _property_names[reset_function_name] = "reset_function_name"
    _property_names[eval_function_name] = "eval_function_name"
    _property_names[unit_dimension] = "unit_dimension"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCustomFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCustomFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCustomFunction, [StateCalcCustomFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4689951577606334035, 12382782284568097196), StateCalcCustomFunction)
agcls.AgTypeNameMap["StateCalcCustomFunction"] = StateCalcCustomFunction

class StateCalcScript(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Script calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_arguments_method_offset = 1
    _get_inline_func_method_offset = 2
    _set_inline_func_method_offset = 3
    _get_unit_dimension_method_offset = 4
    _set_unit_dimension_method_offset = 5
    _get_calculation_object_arguments_link_embed_method_offset = 6
    _metadata = {
        "iid_data" : (5230255327003470545, 156024352906426262),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcScript)

    _get_calculation_object_arguments_metadata = { "offset" : _get_calculation_object_arguments_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_object_arguments(self) -> "CalculationObjectCollection":
        """Get the arguments to be applied to the function."""
        return self._intf.get_property(StateCalcScript._metadata, StateCalcScript._get_calculation_object_arguments_metadata)

    _get_inline_func_metadata = { "offset" : _get_inline_func_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def inline_func(self) -> str:
        """Get or set the expression to be applied as a function."""
        return self._intf.get_property(StateCalcScript._metadata, StateCalcScript._get_inline_func_metadata)

    _set_inline_func_metadata = { "offset" : _set_inline_func_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @inline_func.setter
    def inline_func(self, value:str) -> None:
        return self._intf.set_property(StateCalcScript._metadata, StateCalcScript._set_inline_func_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcScript._metadata, StateCalcScript._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcScript._metadata, StateCalcScript._set_unit_dimension_metadata, value)

    _get_calculation_object_arguments_link_embed_metadata = { "offset" : _get_calculation_object_arguments_link_embed_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_object_arguments_link_embed(self) -> "CalculationObjectLinkEmbedControlCollection":
        """Get the arguments to be applied to the function."""
        return self._intf.get_property(StateCalcScript._metadata, StateCalcScript._get_calculation_object_arguments_link_embed_metadata)

    _property_names[calculation_object_arguments] = "calculation_object_arguments"
    _property_names[inline_func] = "inline_func"
    _property_names[unit_dimension] = "unit_dimension"
    _property_names[calculation_object_arguments_link_embed] = "calculation_object_arguments_link_embed"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcScript."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcScript)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcScript, [StateCalcScript, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5428335731628319644, 2349594956521383600), StateCalcScript)
agcls.AgTypeNameMap["StateCalcScript"] = StateCalcScript

class StateCalcCd(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Cd calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5568518326231174020, 3538034186170905732),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCd)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCd."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCd)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCd, [StateCalcCd, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4749110143901402911, 16411983275256454789), StateCalcCd)
agcls.AgTypeNameMap["StateCalcCd"] = StateCalcCd

class StateCalcCr(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Cr calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5650258084976318033, 16643474672915319172),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCr)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCr."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCr)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCr, [StateCalcCr, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5340250383676600752, 8120486164072751260), StateCalcCr)
agcls.AgTypeNameMap["StateCalcCr"] = StateCalcCr

class StateCalcDragArea(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a DragArea calculation object. CAgAsStateCalcDragArea."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5545976271796063551, 8226493188790136213),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDragArea)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDragArea."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDragArea)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDragArea, [StateCalcDragArea, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5225141382394562543, 5683852515661250210), StateCalcDragArea)
agcls.AgTypeNameMap["StateCalcDragArea"] = StateCalcDragArea

class StateCalcRadiationPressureArea(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RadPressureArea calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5601118184007744281, 5313246703677317260),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRadiationPressureArea)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRadiationPressureArea."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRadiationPressureArea)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRadiationPressureArea, [StateCalcRadiationPressureArea, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4754850115113924725, 2261102432464195480), StateCalcRadiationPressureArea)
agcls.AgTypeNameMap["StateCalcRadiationPressureArea"] = StateCalcRadiationPressureArea

class StateCalcRadiationPressureCoefficient(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a RadiationPressureCoefficient calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5114990569606955072, 2521564829353782433),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRadiationPressureCoefficient)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRadiationPressureCoefficient."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRadiationPressureCoefficient)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRadiationPressureCoefficient, [StateCalcRadiationPressureCoefficient, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5197406241329793753, 9402952683814630335), StateCalcRadiationPressureCoefficient)
agcls.AgTypeNameMap["StateCalcRadiationPressureCoefficient"] = StateCalcRadiationPressureCoefficient

class StateCalcSRPArea(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an SRPArea calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5679124288434228247, 17043898137571845285),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSRPArea)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSRPArea."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSRPArea)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSRPArea, [StateCalcSRPArea, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5114327262628149603, 6327582764702271372), StateCalcSRPArea)
agcls.AgTypeNameMap["StateCalcSRPArea"] = StateCalcSRPArea

class StateCalcCosOfVerticalFlightPathAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Cosine of Vertical FPA calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5109452923180625915, 14418310655883773619),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcCosOfVerticalFlightPathAngle)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcCosOfVerticalFlightPathAngle._metadata, StateCalcCosOfVerticalFlightPathAngle._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcCosOfVerticalFlightPathAngle._metadata, StateCalcCosOfVerticalFlightPathAngle._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcCosOfVerticalFlightPathAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcCosOfVerticalFlightPathAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcCosOfVerticalFlightPathAngle, [StateCalcCosOfVerticalFlightPathAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4912325927198559876, 16519063181087398335), StateCalcCosOfVerticalFlightPathAngle)
agcls.AgTypeNameMap["StateCalcCosOfVerticalFlightPathAngle"] = StateCalcCosOfVerticalFlightPathAngle

class StateCalcDec(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Declination calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5332855122565758901, 9784959898993734033),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDec)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcDec._metadata, StateCalcDec._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDec._metadata, StateCalcDec._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDec."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDec)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDec, [StateCalcDec, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5110197264312311168, 4345047158370537365), StateCalcDec)
agcls.AgTypeNameMap["StateCalcDec"] = StateCalcDec

class StateCalcFlightPathAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Flight Path Angle calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (4635334976117933799, 3713105542969753249),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcFlightPathAngle)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcFlightPathAngle._metadata, StateCalcFlightPathAngle._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcFlightPathAngle._metadata, StateCalcFlightPathAngle._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcFlightPathAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcFlightPathAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcFlightPathAngle, [StateCalcFlightPathAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5560328887180138477, 15449525910187979693), StateCalcFlightPathAngle)
agcls.AgTypeNameMap["StateCalcFlightPathAngle"] = StateCalcFlightPathAngle

class StateCalcRMagnitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an R Mag calculation object. AsStateCalcRMag."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_point_name_method_offset = 1
    _set_reference_point_name_method_offset = 2
    _metadata = {
        "iid_data" : (4627073220849151600, 6473808253627513503),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRMagnitude)

    _get_reference_point_name_metadata = { "offset" : _get_reference_point_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def reference_point_name(self) -> str:
        """Get or set the reference point used for calculation."""
        return self._intf.get_property(StateCalcRMagnitude._metadata, StateCalcRMagnitude._get_reference_point_name_metadata)

    _set_reference_point_name_metadata = { "offset" : _set_reference_point_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @reference_point_name.setter
    def reference_point_name(self, value:str) -> None:
        """Get or set the reference point used for calculation."""
        return self._intf.set_property(StateCalcRMagnitude._metadata, StateCalcRMagnitude._set_reference_point_name_metadata, value)

    _property_names[reference_point_name] = "reference_point_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRMagnitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRMagnitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRMagnitude, [StateCalcRMagnitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4936764719926966041, 8423823670599314579), StateCalcRMagnitude)
agcls.AgTypeNameMap["StateCalcRMagnitude"] = StateCalcRMagnitude

class StateCalcRA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Right Asc calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5521666070512946641, 14878656070581862023),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRA)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcRA._metadata, StateCalcRA._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRA._metadata, StateCalcRA._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRA, [StateCalcRA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5316275584337324043, 11081380491017120702), StateCalcRA)
agcls.AgTypeNameMap["StateCalcRA"] = StateCalcRA

class StateCalcVMagnitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a V Mag calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (4803438129335092965, 6567102418307911588),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVMagnitude)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcVMagnitude._metadata, StateCalcVMagnitude._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVMagnitude._metadata, StateCalcVMagnitude._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVMagnitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVMagnitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVMagnitude, [StateCalcVMagnitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5490853135291077774, 8078175307779202206), StateCalcVMagnitude)
agcls.AgTypeNameMap["StateCalcVMagnitude"] = StateCalcVMagnitude

class StateCalcVelocityAz(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Velocity Azimuth calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (4617414247910404419, 13055723531797471401),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVelocityAz)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcVelocityAz._metadata, StateCalcVelocityAz._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVelocityAz._metadata, StateCalcVelocityAz._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVelocityAz."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVelocityAz)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVelocityAz, [StateCalcVelocityAz, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5165638287317774015, 15762677018237969026), StateCalcVelocityAz)
agcls.AgTypeNameMap["StateCalcVelocityAz"] = StateCalcVelocityAz

class StateCalcC3Energy(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a C3 Energy calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_element_type_method_offset = 3
    _set_element_type_method_offset = 4
    _metadata = {
        "iid_data" : (4795177329830884917, 830721839829273744),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcC3Energy)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcC3Energy._metadata, StateCalcC3Energy._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcC3Energy._metadata, StateCalcC3Energy._set_central_body_name_metadata, value)

    _get_element_type_metadata = { "offset" : _get_element_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @property
    def element_type(self) -> "CalculationObjectElement":
        """Get or set the element type - osculating or a mean type."""
        return self._intf.get_property(StateCalcC3Energy._metadata, StateCalcC3Energy._get_element_type_metadata)

    _set_element_type_metadata = { "offset" : _set_element_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CalculationObjectElement),) }
    @element_type.setter
    def element_type(self, value:"CalculationObjectElement") -> None:
        return self._intf.set_property(StateCalcC3Energy._metadata, StateCalcC3Energy._set_element_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[element_type] = "element_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcC3Energy."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcC3Energy)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcC3Energy, [StateCalcC3Energy, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4956270098886536316, 16711553577682302397), StateCalcC3Energy)
agcls.AgTypeNameMap["StateCalcC3Energy"] = StateCalcC3Energy

class StateCalcInAsympDec(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Incoming Asymptote Dec calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5028189384223465581, 14983870843088691364),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInAsympDec)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcInAsympDec._metadata, StateCalcInAsympDec._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInAsympDec._metadata, StateCalcInAsympDec._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInAsympDec."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInAsympDec)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInAsympDec, [StateCalcInAsympDec, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4720437332510232716, 2971442058362245276), StateCalcInAsympDec)
agcls.AgTypeNameMap["StateCalcInAsympDec"] = StateCalcInAsympDec

class StateCalcInAsympRA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Incoming Asymptote RA calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5492162025506006668, 5827043896990709664),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInAsympRA)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcInAsympRA._metadata, StateCalcInAsympRA._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInAsympRA._metadata, StateCalcInAsympRA._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInAsympRA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInAsympRA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInAsympRA, [StateCalcInAsympRA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5126981333921246025, 18032583169117203367), StateCalcInAsympRA)
agcls.AgTypeNameMap["StateCalcInAsympRA"] = StateCalcInAsympRA

class StateCalcInVelocityAzAtPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Incoming Vel Az at Periapsis calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5283077943529571454, 2469071350249978276),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcInVelocityAzAtPeriapsis)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcInVelocityAzAtPeriapsis._metadata, StateCalcInVelocityAzAtPeriapsis._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcInVelocityAzAtPeriapsis._metadata, StateCalcInVelocityAzAtPeriapsis._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcInVelocityAzAtPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcInVelocityAzAtPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcInVelocityAzAtPeriapsis, [StateCalcInVelocityAzAtPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5179240558843252526, 13982908359142996870), StateCalcInVelocityAzAtPeriapsis)
agcls.AgTypeNameMap["StateCalcInVelocityAzAtPeriapsis"] = StateCalcInVelocityAzAtPeriapsis

class StateCalcOutAsympDec(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Outgoing Asymptote Dec calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (4932054711666868058, 8926848223630516131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOutAsympDec)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcOutAsympDec._metadata, StateCalcOutAsympDec._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOutAsympDec._metadata, StateCalcOutAsympDec._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOutAsympDec."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOutAsympDec)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOutAsympDec, [StateCalcOutAsympDec, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5454981341664221556, 699121151319611538), StateCalcOutAsympDec)
agcls.AgTypeNameMap["StateCalcOutAsympDec"] = StateCalcOutAsympDec

class StateCalcOutAsympRA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Outgoing Asymptote RA calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (4670900581982298440, 12903419386818387345),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOutAsympRA)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcOutAsympRA._metadata, StateCalcOutAsympRA._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOutAsympRA._metadata, StateCalcOutAsympRA._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOutAsympRA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOutAsympRA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOutAsympRA, [StateCalcOutAsympRA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5073736063413390121, 8816824065024077976), StateCalcOutAsympRA)
agcls.AgTypeNameMap["StateCalcOutAsympRA"] = StateCalcOutAsympRA

class StateCalcOutVelocityAzAtPeriapsis(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Outgoing Vel Az at Periapsis calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5683433371167384637, 6985649904241893300),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOutVelocityAzAtPeriapsis)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcOutVelocityAzAtPeriapsis._metadata, StateCalcOutVelocityAzAtPeriapsis._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcOutVelocityAzAtPeriapsis._metadata, StateCalcOutVelocityAzAtPeriapsis._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOutVelocityAzAtPeriapsis."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOutVelocityAzAtPeriapsis)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOutVelocityAzAtPeriapsis, [StateCalcOutVelocityAzAtPeriapsis, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4844314183630368135, 5039558183622268350), StateCalcOutVelocityAzAtPeriapsis)
agcls.AgTypeNameMap["StateCalcOutVelocityAzAtPeriapsis"] = StateCalcOutVelocityAzAtPeriapsis

class StateCalcDuration(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Duration calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5490036406721873421, 17922637933659046047),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDuration)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDuration."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDuration)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDuration, [StateCalcDuration, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5195097791070861727, 15762109350935852979), StateCalcDuration)
agcls.AgTypeNameMap["StateCalcDuration"] = StateCalcDuration

class StateCalcUserValue(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Interface for CAgAsStateCalcUserValue."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_variable_name_method_offset = 1
    _set_variable_name_method_offset = 2
    _metadata = {
        "iid_data" : (5035748028402725444, 2353582877697722512),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcUserValue)

    _get_variable_name_metadata = { "offset" : _get_variable_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_name(self) -> str:
        """Name of the user variable."""
        return self._intf.get_property(StateCalcUserValue._metadata, StateCalcUserValue._get_variable_name_metadata)

    _set_variable_name_metadata = { "offset" : _set_variable_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_name.setter
    def variable_name(self, value:str) -> None:
        """Name of the user variable."""
        return self._intf.set_property(StateCalcUserValue._metadata, StateCalcUserValue._set_variable_name_metadata, value)

    _property_names[variable_name] = "variable_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcUserValue."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcUserValue)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcUserValue, [StateCalcUserValue, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5075893719684406414, 309963419781242501), StateCalcUserValue)
agcls.AgTypeNameMap["StateCalcUserValue"] = StateCalcUserValue

class StateCalcVectorGeometryToolAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Vector Geometry Tool Angle calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_angle_name_method_offset = 1
    _set_angle_name_method_offset = 2
    _metadata = {
        "iid_data" : (4652639349765645987, 11922436072353264798),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorGeometryToolAngle)

    _get_angle_name_metadata = { "offset" : _get_angle_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def angle_name(self) -> str:
        """Get or set the angle."""
        return self._intf.get_property(StateCalcVectorGeometryToolAngle._metadata, StateCalcVectorGeometryToolAngle._get_angle_name_metadata)

    _set_angle_name_metadata = { "offset" : _set_angle_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @angle_name.setter
    def angle_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorGeometryToolAngle._metadata, StateCalcVectorGeometryToolAngle._set_angle_name_metadata, value)

    _property_names[angle_name] = "angle_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorGeometryToolAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorGeometryToolAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorGeometryToolAngle, [StateCalcVectorGeometryToolAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5644255745704344347, 14430080963520259744), StateCalcVectorGeometryToolAngle)
agcls.AgTypeNameMap["StateCalcVectorGeometryToolAngle"] = StateCalcVectorGeometryToolAngle

class StateCalcAngle(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Angle Between Vectors calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_vector1_name_method_offset = 1
    _set_vector1_name_method_offset = 2
    _get_vector2_name_method_offset = 3
    _set_vector2_name_method_offset = 4
    _metadata = {
        "iid_data" : (4646373445201032634, 18417239879106946699),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcAngle)

    _get_vector1_name_metadata = { "offset" : _get_vector1_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector1_name(self) -> str:
        """Get or set the first vector of the angle."""
        return self._intf.get_property(StateCalcAngle._metadata, StateCalcAngle._get_vector1_name_metadata)

    _set_vector1_name_metadata = { "offset" : _set_vector1_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector1_name.setter
    def vector1_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcAngle._metadata, StateCalcAngle._set_vector1_name_metadata, value)

    _get_vector2_name_metadata = { "offset" : _get_vector2_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector2_name(self) -> str:
        """Get or set the second vector of the angle."""
        return self._intf.get_property(StateCalcAngle._metadata, StateCalcAngle._get_vector2_name_metadata)

    _set_vector2_name_metadata = { "offset" : _set_vector2_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector2_name.setter
    def vector2_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcAngle._metadata, StateCalcAngle._set_vector2_name_metadata, value)

    _property_names[vector1_name] = "vector1_name"
    _property_names[vector2_name] = "vector2_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcAngle."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcAngle)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcAngle, [StateCalcAngle, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5256397510869147384, 11126367831258958237), StateCalcAngle)
agcls.AgTypeNameMap["StateCalcAngle"] = StateCalcAngle

class StateCalcDotProduct(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Dot Product calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_vector1_name_method_offset = 1
    _set_vector1_name_method_offset = 2
    _get_vector2_name_method_offset = 3
    _set_vector2_name_method_offset = 4
    _metadata = {
        "iid_data" : (5247109097718579843, 218601991849819583),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDotProduct)

    _get_vector1_name_metadata = { "offset" : _get_vector1_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector1_name(self) -> str:
        """Get or set the first vector."""
        return self._intf.get_property(StateCalcDotProduct._metadata, StateCalcDotProduct._get_vector1_name_metadata)

    _set_vector1_name_metadata = { "offset" : _set_vector1_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector1_name.setter
    def vector1_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDotProduct._metadata, StateCalcDotProduct._set_vector1_name_metadata, value)

    _get_vector2_name_metadata = { "offset" : _get_vector2_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector2_name(self) -> str:
        """Get or set the second vector."""
        return self._intf.get_property(StateCalcDotProduct._metadata, StateCalcDotProduct._get_vector2_name_metadata)

    _set_vector2_name_metadata = { "offset" : _set_vector2_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector2_name.setter
    def vector2_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDotProduct._metadata, StateCalcDotProduct._set_vector2_name_metadata, value)

    _property_names[vector1_name] = "vector1_name"
    _property_names[vector2_name] = "vector2_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDotProduct."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDotProduct)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDotProduct, [StateCalcDotProduct, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4961147482972533505, 3292612509947718841), StateCalcDotProduct)
agcls.AgTypeNameMap["StateCalcDotProduct"] = StateCalcDotProduct

class StateCalcVectorDec(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector Dec calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _get_vector_name_method_offset = 3
    _set_vector_name_method_offset = 4
    _metadata = {
        "iid_data" : (5585535507402187666, 4555090200354434236),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorDec)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcVectorDec._metadata, StateCalcVectorDec._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorDec._metadata, StateCalcVectorDec._set_coord_axes_name_metadata, value)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorDec._metadata, StateCalcVectorDec._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorDec._metadata, StateCalcVectorDec._set_vector_name_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"
    _property_names[vector_name] = "vector_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorDec."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorDec)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorDec, [StateCalcVectorDec, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5206425262316127545, 3424396666528829351), StateCalcVectorDec)
agcls.AgTypeNameMap["StateCalcVectorDec"] = StateCalcVectorDec

class StateCalcVectorMagnitude(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector Mag calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_vector_name_method_offset = 1
    _set_vector_name_method_offset = 2
    _get_unit_dimension_method_offset = 3
    _set_unit_dimension_method_offset = 4
    _metadata = {
        "iid_data" : (5324102475805554083, 8037218018821806739),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorMagnitude)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorMagnitude._metadata, StateCalcVectorMagnitude._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorMagnitude._metadata, StateCalcVectorMagnitude._set_vector_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcVectorMagnitude._metadata, StateCalcVectorMagnitude._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorMagnitude._metadata, StateCalcVectorMagnitude._set_unit_dimension_metadata, value)

    _property_names[vector_name] = "vector_name"
    _property_names[unit_dimension] = "unit_dimension"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorMagnitude."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorMagnitude)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorMagnitude, [StateCalcVectorMagnitude, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5596838771871567286, 16483514214233658248), StateCalcVectorMagnitude)
agcls.AgTypeNameMap["StateCalcVectorMagnitude"] = StateCalcVectorMagnitude

class StateCalcVectorRA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector RA calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _get_vector_name_method_offset = 3
    _set_vector_name_method_offset = 4
    _metadata = {
        "iid_data" : (5107356567157566993, 12516705800010121347),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorRA)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcVectorRA._metadata, StateCalcVectorRA._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorRA._metadata, StateCalcVectorRA._set_coord_axes_name_metadata, value)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorRA._metadata, StateCalcVectorRA._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorRA._metadata, StateCalcVectorRA._set_vector_name_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"
    _property_names[vector_name] = "vector_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorRA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorRA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorRA, [StateCalcVectorRA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5661294235670981293, 865349632008221838), StateCalcVectorRA)
agcls.AgTypeNameMap["StateCalcVectorRA"] = StateCalcVectorRA

class StateCalcVectorX(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Vector X calculation object."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_axes_name_method_offset = 1
    _set_coord_axes_name_method_offset = 2
    _get_vector_name_method_offset = 3
    _set_vector_name_method_offset = 4
    _get_unit_dimension_method_offset = 5
    _set_unit_dimension_method_offset = 6
    _get_normalize_method_offset = 7
    _set_normalize_method_offset = 8
    _metadata = {
        "iid_data" : (5141058384301335384, 13279974180234312123),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcVectorX)

    _get_coord_axes_name_metadata = { "offset" : _get_coord_axes_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_axes_name(self) -> str:
        """Get or set the coordinate axes."""
        return self._intf.get_property(StateCalcVectorX._metadata, StateCalcVectorX._get_coord_axes_name_metadata)

    _set_coord_axes_name_metadata = { "offset" : _set_coord_axes_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_axes_name.setter
    def coord_axes_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorX._metadata, StateCalcVectorX._set_coord_axes_name_metadata, value)

    _get_vector_name_metadata = { "offset" : _get_vector_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vector_name(self) -> str:
        """Get or set the vector."""
        return self._intf.get_property(StateCalcVectorX._metadata, StateCalcVectorX._get_vector_name_metadata)

    _set_vector_name_metadata = { "offset" : _set_vector_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vector_name.setter
    def vector_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorX._metadata, StateCalcVectorX._set_vector_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcVectorX._metadata, StateCalcVectorX._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcVectorX._metadata, StateCalcVectorX._set_unit_dimension_metadata, value)

    _get_normalize_metadata = { "offset" : _get_normalize_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def normalize(self) -> bool:
        """If true, return the normalized magnitude."""
        return self._intf.get_property(StateCalcVectorX._metadata, StateCalcVectorX._get_normalize_metadata)

    _set_normalize_metadata = { "offset" : _set_normalize_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @normalize.setter
    def normalize(self, value:bool) -> None:
        return self._intf.set_property(StateCalcVectorX._metadata, StateCalcVectorX._set_normalize_metadata, value)

    _property_names[coord_axes_name] = "coord_axes_name"
    _property_names[vector_name] = "vector_name"
    _property_names[unit_dimension] = "unit_dimension"
    _property_names[normalize] = "normalize"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcVectorX."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcVectorX)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcVectorX, [StateCalcVectorX, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5375549622553239861, 624849717514265264), StateCalcVectorX)
agcls.AgTypeNameMap["StateCalcVectorX"] = StateCalcVectorX

class StateCalcOnePointAccess(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Access calculation object."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aberration_type_method_offset = 1
    _set_aberration_type_method_offset = 2
    _set_base_selection_method_offset = 3
    _get_base_selection_type_method_offset = 4
    _get_base_selection_method_offset = 5
    _get_clock_host_method_offset = 6
    _set_clock_host_method_offset = 7
    _get_signal_sense_method_offset = 8
    _set_signal_sense_method_offset = 9
    _get_target_object_method_offset = 10
    _get_time_delay_convergence_tolerance_method_offset = 11
    _set_time_delay_convergence_tolerance_method_offset = 12
    _get_use_light_time_delay_method_offset = 13
    _set_use_light_time_delay_method_offset = 14
    _metadata = {
        "iid_data" : (5258287937174969888, 14447982092743172993),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcOnePointAccess)

    _get_aberration_type_metadata = { "offset" : _get_aberration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AberrationType),) }
    @property
    def aberration_type(self) -> "AberrationType":
        """Get or set the type of aberration to use, if light time delay is applied."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_aberration_type_metadata)

    _set_aberration_type_metadata = { "offset" : _set_aberration_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AberrationType),) }
    @aberration_type.setter
    def aberration_type(self, value:"AberrationType") -> None:
        return self._intf.set_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_aberration_type_metadata, value)

    _set_base_selection_metadata = { "offset" : _set_base_selection_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BaseSelection),) }
    def set_base_selection(self, selection:"BaseSelection") -> None:
        """Set the base selection."""
        return self._intf.invoke(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_base_selection_metadata, selection)

    _get_base_selection_type_metadata = { "offset" : _get_base_selection_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BaseSelection),) }
    @property
    def base_selection_type(self) -> "BaseSelection":
        """Get the base selection type."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_base_selection_type_metadata)

    _get_base_selection_metadata = { "offset" : _get_base_selection_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def base_selection(self) -> "ILinkToObject":
        """Get the base selection object."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_base_selection_metadata)

    _get_clock_host_metadata = { "offset" : _get_clock_host_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IvClockHost),) }
    @property
    def clock_host(self) -> "IvClockHost":
        """Get or set the object whose location is associated with time."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_clock_host_metadata)

    _set_clock_host_metadata = { "offset" : _set_clock_host_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IvClockHost),) }
    @clock_host.setter
    def clock_host(self, value:"IvClockHost") -> None:
        return self._intf.set_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_clock_host_metadata, value)

    _get_signal_sense_metadata = { "offset" : _get_signal_sense_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IvTimeSense),) }
    @property
    def signal_sense(self) -> "IvTimeSense":
        """Sense of the signal at the base object."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_signal_sense_metadata)

    _set_signal_sense_metadata = { "offset" : _set_signal_sense_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IvTimeSense),) }
    @signal_sense.setter
    def signal_sense(self, value:"IvTimeSense") -> None:
        return self._intf.set_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_signal_sense_metadata, value)

    _get_target_object_metadata = { "offset" : _get_target_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def target_object(self) -> "ILinkToObject":
        """Get the target object."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_target_object_metadata)

    _get_time_delay_convergence_tolerance_metadata = { "offset" : _get_time_delay_convergence_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_delay_convergence_tolerance(self) -> float:
        """Get or set the time delay convergence tolerance, if light time delay is applied. Uses Time Dimension."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_time_delay_convergence_tolerance_metadata)

    _set_time_delay_convergence_tolerance_metadata = { "offset" : _set_time_delay_convergence_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_delay_convergence_tolerance.setter
    def time_delay_convergence_tolerance(self, value:float) -> None:
        return self._intf.set_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_time_delay_convergence_tolerance_metadata, value)

    _get_use_light_time_delay_metadata = { "offset" : _get_use_light_time_delay_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_light_time_delay(self) -> bool:
        """Tue if light time delay is applied."""
        return self._intf.get_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._get_use_light_time_delay_metadata)

    _set_use_light_time_delay_metadata = { "offset" : _set_use_light_time_delay_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_light_time_delay.setter
    def use_light_time_delay(self, value:bool) -> None:
        return self._intf.set_property(StateCalcOnePointAccess._metadata, StateCalcOnePointAccess._set_use_light_time_delay_metadata, value)

    _property_names[aberration_type] = "aberration_type"
    _property_names[base_selection_type] = "base_selection_type"
    _property_names[base_selection] = "base_selection"
    _property_names[clock_host] = "clock_host"
    _property_names[signal_sense] = "signal_sense"
    _property_names[target_object] = "target_object"
    _property_names[time_delay_convergence_tolerance] = "time_delay_convergence_tolerance"
    _property_names[use_light_time_delay] = "use_light_time_delay"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcOnePointAccess."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcOnePointAccess)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcOnePointAccess, [StateCalcOnePointAccess, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5722868679097170223, 4646008177610324386), StateCalcOnePointAccess)
agcls.AgTypeNameMap["StateCalcOnePointAccess"] = StateCalcOnePointAccess

class StateCalcDifferenceAcrossSegmentsOtherSatellite(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Difference Across Segments Across Satellites calculation object."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_other_segment_name_method_offset = 3
    _set_other_segment_name_method_offset = 4
    _get_segment_state_to_use_method_offset = 5
    _set_segment_state_to_use_method_offset = 6
    _get_difference_order_method_offset = 7
    _set_difference_order_method_offset = 8
    _get_reference_satellite_method_offset = 9
    _metadata = {
        "iid_data" : (5586974997613699158, 7969105052204490661),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDifferenceAcrossSegmentsOtherSatellite)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._set_calculation_object_name_metadata, value)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._set_segment_state_to_use_metadata, value)

    _get_difference_order_metadata = { "offset" : _get_difference_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentDifferenceOrder),) }
    @property
    def difference_order(self) -> "SegmentDifferenceOrder":
        """Get or set the order of the difference calculation."""
        return self._intf.get_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._get_difference_order_metadata)

    _set_difference_order_metadata = { "offset" : _set_difference_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentDifferenceOrder),) }
    @difference_order.setter
    def difference_order(self, value:"SegmentDifferenceOrder") -> None:
        return self._intf.set_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._set_difference_order_metadata, value)

    _get_reference_satellite_metadata = { "offset" : _get_reference_satellite_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference_satellite(self) -> "ILinkToObject":
        """Get the Astrogator satellite on which the segment to be compared exists."""
        return self._intf.get_property(StateCalcDifferenceAcrossSegmentsOtherSatellite._metadata, StateCalcDifferenceAcrossSegmentsOtherSatellite._get_reference_satellite_metadata)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"
    _property_names[difference_order] = "difference_order"
    _property_names[reference_satellite] = "reference_satellite"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDifferenceAcrossSegmentsOtherSatellite."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDifferenceAcrossSegmentsOtherSatellite)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDifferenceAcrossSegmentsOtherSatellite, [StateCalcDifferenceAcrossSegmentsOtherSatellite, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5535002555039008667, 9414753759363378563), StateCalcDifferenceAcrossSegmentsOtherSatellite)
agcls.AgTypeNameMap["StateCalcDifferenceAcrossSegmentsOtherSatellite"] = StateCalcDifferenceAcrossSegmentsOtherSatellite

class StateCalcValueAtSegmentOtherSat(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Value At Segment Across Satellites calculation object."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_calculation_object_name_method_offset = 1
    _set_calculation_object_name_method_offset = 2
    _get_other_segment_name_method_offset = 3
    _set_other_segment_name_method_offset = 4
    _get_segment_state_to_use_method_offset = 5
    _set_segment_state_to_use_method_offset = 6
    _get_reference_satellite_method_offset = 7
    _metadata = {
        "iid_data" : (4861373002110940755, 14099853278507236280),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcValueAtSegmentOtherSat)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the calculation object."""
        return self._intf.get_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._set_calculation_object_name_metadata, value)

    _get_other_segment_name_metadata = { "offset" : _get_other_segment_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def other_segment_name(self) -> str:
        """Get or set the segment to be compared against."""
        return self._intf.get_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._get_other_segment_name_metadata)

    _set_other_segment_name_metadata = { "offset" : _set_other_segment_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @other_segment_name.setter
    def other_segment_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._set_other_segment_name_metadata, value)

    _get_segment_state_to_use_metadata = { "offset" : _get_segment_state_to_use_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @property
    def segment_state_to_use(self) -> "SegmentState":
        """Get or set the segment state to use in the calculation."""
        return self._intf.get_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._get_segment_state_to_use_metadata)

    _set_segment_state_to_use_metadata = { "offset" : _set_segment_state_to_use_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SegmentState),) }
    @segment_state_to_use.setter
    def segment_state_to_use(self, value:"SegmentState") -> None:
        return self._intf.set_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._set_segment_state_to_use_metadata, value)

    _get_reference_satellite_metadata = { "offset" : _get_reference_satellite_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def reference_satellite(self) -> "ILinkToObject":
        """Get the Astrogator satellite on which the segment to be compared exists."""
        return self._intf.get_property(StateCalcValueAtSegmentOtherSat._metadata, StateCalcValueAtSegmentOtherSat._get_reference_satellite_metadata)

    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[other_segment_name] = "other_segment_name"
    _property_names[segment_state_to_use] = "segment_state_to_use"
    _property_names[reference_satellite] = "reference_satellite"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcValueAtSegmentOtherSat."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcValueAtSegmentOtherSat)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcValueAtSegmentOtherSat, [StateCalcValueAtSegmentOtherSat, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5100707839553253780, 16681457764805949839), StateCalcValueAtSegmentOtherSat)
agcls.AgTypeNameMap["StateCalcValueAtSegmentOtherSat"] = StateCalcValueAtSegmentOtherSat

class StateCalcRARate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Right Ascension Rate calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5169312735323609372, 1351559487964280729),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRARate)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcRARate._metadata, StateCalcRARate._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRARate._metadata, StateCalcRARate._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRARate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRARate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRARate, [StateCalcRARate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5427418789905619045, 7913717464183850941), StateCalcRARate)
agcls.AgTypeNameMap["StateCalcRARate"] = StateCalcRARate

class StateCalcDecRate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Declination Rate calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5198081004019154854, 16296709300563218824),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcDecRate)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcDecRate._metadata, StateCalcDecRate._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcDecRate._metadata, StateCalcDecRate._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcDecRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcDecRate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcDecRate, [StateCalcDecRate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5447811881180074853, 16119053664595181462), StateCalcDecRate)
agcls.AgTypeNameMap["StateCalcDecRate"] = StateCalcDecRate

class StateCalcRangeRate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Range Rate calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _metadata = {
        "iid_data" : (5190417108120997032, 7467177326937025207),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcRangeRate)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """The coordinate system within which the element is defined."""
        return self._intf.get_property(StateCalcRangeRate._metadata, StateCalcRangeRate._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcRangeRate._metadata, StateCalcRangeRate._set_coord_system_name_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcRangeRate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcRangeRate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcRangeRate, [StateCalcRangeRate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5739329804608567404, 2124500646456044975), StateCalcRangeRate)
agcls.AgTypeNameMap["StateCalcRangeRate"] = StateCalcRangeRate

class StateCalcGravitationalParameter(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Gravitational Parameter calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_gravitational_parameter_source_method_offset = 3
    _set_gravitational_parameter_source_method_offset = 4
    _get_gravity_filename_method_offset = 5
    _set_gravity_filename_method_offset = 6
    _metadata = {
        "iid_data" : (4656334884063867319, 15050515386662574250),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGravitationalParameter)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._set_central_body_name_metadata, value)

    _get_gravitational_parameter_source_metadata = { "offset" : _get_gravitational_parameter_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GravitationalParameterSource),) }
    @property
    def gravitational_parameter_source(self) -> "GravitationalParameterSource":
        """Get or set the source for the gravitational parameter."""
        return self._intf.get_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._get_gravitational_parameter_source_metadata)

    _set_gravitational_parameter_source_metadata = { "offset" : _set_gravitational_parameter_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GravitationalParameterSource),) }
    @gravitational_parameter_source.setter
    def gravitational_parameter_source(self, value:"GravitationalParameterSource") -> None:
        return self._intf.set_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._set_gravitational_parameter_source_metadata, value)

    _get_gravity_filename_metadata = { "offset" : _get_gravity_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def gravity_filename(self) -> str:
        """Source for the gravitational parameter if GravSource is set to Gravity File."""
        return self._intf.get_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._get_gravity_filename_metadata)

    _set_gravity_filename_metadata = { "offset" : _set_gravity_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @gravity_filename.setter
    def gravity_filename(self, value:str) -> None:
        return self._intf.set_property(StateCalcGravitationalParameter._metadata, StateCalcGravitationalParameter._set_gravity_filename_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[gravitational_parameter_source] = "gravitational_parameter_source"
    _property_names[gravity_filename] = "gravity_filename"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGravitationalParameter."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGravitationalParameter)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGravitationalParameter, [StateCalcGravitationalParameter, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5336449706727541927, 12029373292348620448), StateCalcGravitationalParameter)
agcls.AgTypeNameMap["StateCalcGravitationalParameter"] = StateCalcGravitationalParameter

class StateCalcReferenceRadius(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Reference Radius calculation object."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_reference_radius_source_method_offset = 3
    _set_reference_radius_source_method_offset = 4
    _get_gravity_filename_method_offset = 5
    _set_gravity_filename_method_offset = 6
    _metadata = {
        "iid_data" : (5257402151595319831, 4633460210786368153),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcReferenceRadius)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._set_central_body_name_metadata, value)

    _get_reference_radius_source_metadata = { "offset" : _get_reference_radius_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceRadiusSource),) }
    @property
    def reference_radius_source(self) -> "ReferenceRadiusSource":
        """Get or set the source for the reference radius."""
        return self._intf.get_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._get_reference_radius_source_metadata)

    _set_reference_radius_source_metadata = { "offset" : _set_reference_radius_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ReferenceRadiusSource),) }
    @reference_radius_source.setter
    def reference_radius_source(self, value:"ReferenceRadiusSource") -> None:
        return self._intf.set_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._set_reference_radius_source_metadata, value)

    _get_gravity_filename_metadata = { "offset" : _get_gravity_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def gravity_filename(self) -> str:
        """Source for the reference radius if RefRadSource is set to Gravity File."""
        return self._intf.get_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._get_gravity_filename_metadata)

    _set_gravity_filename_metadata = { "offset" : _set_gravity_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @gravity_filename.setter
    def gravity_filename(self, value:str) -> None:
        return self._intf.set_property(StateCalcReferenceRadius._metadata, StateCalcReferenceRadius._set_gravity_filename_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[reference_radius_source] = "reference_radius_source"
    _property_names[gravity_filename] = "gravity_filename"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcReferenceRadius."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcReferenceRadius)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcReferenceRadius, [StateCalcReferenceRadius, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5190710319823653137, 614989305931214249), StateCalcReferenceRadius)
agcls.AgTypeNameMap["StateCalcReferenceRadius"] = StateCalcReferenceRadius

class StateCalcGravCoeff(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a gravity coefficient calculation object."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_gravity_filename_method_offset = 3
    _set_gravity_filename_method_offset = 4
    _get_coefficient_type_method_offset = 5
    _set_coefficient_type_method_offset = 6
    _get_degree_method_offset = 7
    _set_degree_method_offset = 8
    _get_order_method_offset = 9
    _set_order_method_offset = 10
    _get_normalization_type_method_offset = 11
    _set_normalization_type_method_offset = 12
    _metadata = {
        "iid_data" : (5076942001580635825, 11057982484705034399),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcGravCoeff)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_central_body_name_metadata, value)

    _get_gravity_filename_metadata = { "offset" : _get_gravity_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def gravity_filename(self) -> str:
        """Source for the gravity coefficient."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_gravity_filename_metadata)

    _set_gravity_filename_metadata = { "offset" : _set_gravity_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @gravity_filename.setter
    def gravity_filename(self, value:str) -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_gravity_filename_metadata, value)

    _get_coefficient_type_metadata = { "offset" : _get_coefficient_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GravityCoefficientType),) }
    @property
    def coefficient_type(self) -> "GravityCoefficientType":
        """Coefficient type."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_coefficient_type_metadata)

    _set_coefficient_type_metadata = { "offset" : _set_coefficient_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GravityCoefficientType),) }
    @coefficient_type.setter
    def coefficient_type(self, value:"GravityCoefficientType") -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_coefficient_type_metadata, value)

    _get_degree_metadata = { "offset" : _get_degree_method_offset,
            "arg_types" : (POINTER(agcom.INT),),
            "marshallers" : (agmarshall.IntArg,) }
    @property
    def degree(self) -> int:
        """Degree of the coefficient."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_degree_metadata)

    _set_degree_metadata = { "offset" : _set_degree_method_offset,
            "arg_types" : (agcom.INT,),
            "marshallers" : (agmarshall.IntArg,) }
    @degree.setter
    def degree(self, value:int) -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_degree_metadata, value)

    _get_order_metadata = { "offset" : _get_order_method_offset,
            "arg_types" : (POINTER(agcom.INT),),
            "marshallers" : (agmarshall.IntArg,) }
    @property
    def order(self) -> int:
        """Order of the coefficient."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_order_metadata)

    _set_order_metadata = { "offset" : _set_order_method_offset,
            "arg_types" : (agcom.INT,),
            "marshallers" : (agmarshall.IntArg,) }
    @order.setter
    def order(self, value:int) -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_order_metadata, value)

    _get_normalization_type_metadata = { "offset" : _get_normalization_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GravityCoefficientNormalizationType),) }
    @property
    def normalization_type(self) -> "GravityCoefficientNormalizationType":
        """Normalization type."""
        return self._intf.get_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._get_normalization_type_metadata)

    _set_normalization_type_metadata = { "offset" : _set_normalization_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GravityCoefficientNormalizationType),) }
    @normalization_type.setter
    def normalization_type(self, value:"GravityCoefficientNormalizationType") -> None:
        return self._intf.set_property(StateCalcGravCoeff._metadata, StateCalcGravCoeff._set_normalization_type_metadata, value)

    _property_names[central_body_name] = "central_body_name"
    _property_names[gravity_filename] = "gravity_filename"
    _property_names[coefficient_type] = "coefficient_type"
    _property_names[degree] = "degree"
    _property_names[order] = "order"
    _property_names[normalization_type] = "normalization_type"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcGravCoeff."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcGravCoeff)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcGravCoeff, [StateCalcGravCoeff, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4936078533960285641, 14479037150342646414), StateCalcGravCoeff)
agcls.AgTypeNameMap["StateCalcGravCoeff"] = StateCalcGravCoeff

class StateCalcSpeedOfLight(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Speed of Light calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5680239566686852476, 16205282188573228188),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcSpeedOfLight)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcSpeedOfLight."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcSpeedOfLight)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcSpeedOfLight, [StateCalcSpeedOfLight, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4887361465284887889, 17594890200945376905), StateCalcSpeedOfLight)
agcls.AgTypeNameMap["StateCalcSpeedOfLight"] = StateCalcSpeedOfLight

class StateCalcPi(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Pi calculation object."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5708338168074948532, 1281499724932318355),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcPi)


    def __init__(self, source_object=None):
        """Construct an object of type StateCalcPi."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcPi)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcPi, [StateCalcPi, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5630115082508146498, 5734333376350242177), StateCalcPi)
agcls.AgTypeNameMap["StateCalcPi"] = StateCalcPi

class StateCalcScalar(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Scalar calculation object."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_scalar_name_method_offset = 1
    _set_scalar_name_method_offset = 2
    _get_unit_dimension_method_offset = 3
    _set_unit_dimension_method_offset = 4
    _metadata = {
        "iid_data" : (4629925575624144000, 12136319558661325245),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcScalar)

    _get_scalar_name_metadata = { "offset" : _get_scalar_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def scalar_name(self) -> str:
        """Get or set the scalar name."""
        return self._intf.get_property(StateCalcScalar._metadata, StateCalcScalar._get_scalar_name_metadata)

    _set_scalar_name_metadata = { "offset" : _set_scalar_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @scalar_name.setter
    def scalar_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcScalar._metadata, StateCalcScalar._set_scalar_name_metadata, value)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the unit dimension."""
        return self._intf.get_property(StateCalcScalar._metadata, StateCalcScalar._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        return self._intf.set_property(StateCalcScalar._metadata, StateCalcScalar._set_unit_dimension_metadata, value)

    _property_names[scalar_name] = "scalar_name"
    _property_names[unit_dimension] = "unit_dimension"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcScalar."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcScalar)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcScalar, [StateCalcScalar, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5353708507660250487, 8836083805435505283), StateCalcScalar)
agcls.AgTypeNameMap["StateCalcScalar"] = StateCalcScalar

class StateCalcApparentSolarTime(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Apparent Solar Time calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5014389841226027657, 1424149512299130022),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcApparentSolarTime)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcApparentSolarTime._metadata, StateCalcApparentSolarTime._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcApparentSolarTime._metadata, StateCalcApparentSolarTime._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcApparentSolarTime."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcApparentSolarTime)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcApparentSolarTime, [StateCalcApparentSolarTime, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5371855221923459945, 3280181261227876787), StateCalcApparentSolarTime)
agcls.AgTypeNameMap["StateCalcApparentSolarTime"] = StateCalcApparentSolarTime

class StateCalcEarthMeanSolarTime(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Earth Mean Solar Time calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5379733726693653889, 7167384767267044780),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEarthMeanSolarTime)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEarthMeanSolarTime._metadata, StateCalcEarthMeanSolarTime._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEarthMeanSolarTime._metadata, StateCalcEarthMeanSolarTime._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEarthMeanSolarTime."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEarthMeanSolarTime)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEarthMeanSolarTime, [StateCalcEarthMeanSolarTime, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4650491514545192557, 13776968428773292448), StateCalcEarthMeanSolarTime)
agcls.AgTypeNameMap["StateCalcEarthMeanSolarTime"] = StateCalcEarthMeanSolarTime

class StateCalcEarthMeanLocalTimeOfAscendingNode(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for an Earth Mean Local Time of Ascending Node calculation object."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _metadata = {
        "iid_data" : (5434713757343168361, 2937764617524906412),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateCalcEarthMeanLocalTimeOfAscendingNode)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body of the component."""
        return self._intf.get_property(StateCalcEarthMeanLocalTimeOfAscendingNode._metadata, StateCalcEarthMeanLocalTimeOfAscendingNode._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(StateCalcEarthMeanLocalTimeOfAscendingNode._metadata, StateCalcEarthMeanLocalTimeOfAscendingNode._set_central_body_name_metadata, value)

    _property_names[central_body_name] = "central_body_name"

    def __init__(self, source_object=None):
        """Construct an object of type StateCalcEarthMeanLocalTimeOfAscendingNode."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateCalcEarthMeanLocalTimeOfAscendingNode)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateCalcEarthMeanLocalTimeOfAscendingNode, [StateCalcEarthMeanLocalTimeOfAscendingNode, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5240793249526993676, 4585501919491212454), StateCalcEarthMeanLocalTimeOfAscendingNode)
agcls.AgTypeNameMap["StateCalcEarthMeanLocalTimeOfAscendingNode"] = StateCalcEarthMeanLocalTimeOfAscendingNode

class AutomaticSequenceCollection(SupportsDeleteCallback):
    """Properties for the Automatic Sequence Browser."""

    _num_methods = 7
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _get_item_by_index_method_offset = 6
    _get_item_by_name_method_offset = 7
    _metadata = {
        "iid_data" : (5663305449015703647, 15861498692559094205),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AutomaticSequenceCollection)
    def __iter__(self):
        """Create an iterator for the AutomaticSequenceCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "AutomaticSequence":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "AutomaticSequence":
        """Return the given automatic sequence."""
        return self._intf.invoke(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, name:str) -> "AutomaticSequence":
        """Create a new sequence."""
        return self._intf.invoke(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._add_metadata, name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a sequence."""
        return self._intf.invoke(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Get the size of the collection."""
        return self._intf.get_property(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "AutomaticSequence":
        """Retrieve the given automatic sequence found by the index."""
        return self._intf.invoke(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "AutomaticSequence":
        """Retrieve the given automatic sequence found by the name."""
        return self._intf.invoke(AutomaticSequenceCollection._metadata, AutomaticSequenceCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type AutomaticSequenceCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AutomaticSequenceCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AutomaticSequenceCollection, [AutomaticSequenceCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5071595060173986658, 13823054959921785768), AutomaticSequenceCollection)
agcls.AgTypeNameMap["AutomaticSequenceCollection"] = AutomaticSequenceCollection

class AutomaticSequence(SupportsDeleteCallback):
    """Properties for automatic sequences."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _make_copy_method_offset = 1
    _get_name_method_offset = 2
    _set_name_method_offset = 3
    _get_user_comment_method_offset = 4
    _set_user_comment_method_offset = 5
    _get_sequence_method_offset = 6
    _metadata = {
        "iid_data" : (5730995391160895162, 12407851123050192288),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AutomaticSequence)

    _make_copy_metadata = { "offset" : _make_copy_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def make_copy(self, unique_name:str) -> "AutomaticSequence":
        """Make a copy of the sequence."""
        return self._intf.invoke(AutomaticSequence._metadata, AutomaticSequence._make_copy_metadata, unique_name, OutArg())

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get or set the name of the sequence."""
        return self._intf.get_property(AutomaticSequence._metadata, AutomaticSequence._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        return self._intf.set_property(AutomaticSequence._metadata, AutomaticSequence._set_name_metadata, value)

    _get_user_comment_metadata = { "offset" : _get_user_comment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_comment(self) -> str:
        """Get or set the user comment."""
        return self._intf.get_property(AutomaticSequence._metadata, AutomaticSequence._get_user_comment_metadata)

    _set_user_comment_metadata = { "offset" : _set_user_comment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_comment.setter
    def user_comment(self, value:str) -> None:
        return self._intf.set_property(AutomaticSequence._metadata, AutomaticSequence._set_user_comment_metadata, value)

    _get_sequence_metadata = { "offset" : _get_sequence_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def sequence(self) -> "MCSSegmentCollection":
        """Return the segment collection of the sequence."""
        return self._intf.get_property(AutomaticSequence._metadata, AutomaticSequence._get_sequence_metadata)

    _property_names[name] = "name"
    _property_names[user_comment] = "user_comment"
    _property_names[sequence] = "sequence"

    def __init__(self, source_object=None):
        """Construct an object of type AutomaticSequence."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AutomaticSequence)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AutomaticSequence, [AutomaticSequence, ])

agcls.AgClassCatalog.add_catalog_entry((5084262556472041234, 3752935948797194130), AutomaticSequence)
agcls.AgTypeNameMap["AutomaticSequence"] = AutomaticSequence

class CentralBodyComponentCollection(SupportsDeleteCallback):
    """The list of central bodies."""

    _num_methods = 8
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get_count_method_offset = 2
    _get__new_enum_method_offset = 3
    _add_method_offset = 4
    _remove_method_offset = 5
    _remove_all_method_offset = 6
    _get_item_by_index_method_offset = 7
    _get_item_by_name_method_offset = 8
    _metadata = {
        "iid_data" : (4871753960793045745, 5335968105475417007),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentCollection)
    def __iter__(self):
        """Create an iterator for the CentralBodyComponentCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "CentralBodyComponent":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_cb_name:typing.Any) -> "CentralBodyComponent":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._item_metadata, index_or_cb_name, OutArg())

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._get_count_metadata)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Iterates through the collection."""
        return self._intf.get_property(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._get__new_enum_metadata)

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def add(self, cb_name:str) -> None:
        """Add a central body to the collection."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._add_metadata, cb_name)

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a central body from the collection."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all central bodies from the collection."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._remove_all_metadata, )

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "CentralBodyComponent":
        """Retrieve a central body from the collection by index."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, cb_name:str) -> "CentralBodyComponent":
        """Retrieve a central body from the collection by name."""
        return self._intf.invoke(CentralBodyComponentCollection._metadata, CentralBodyComponentCollection._get_item_by_name_metadata, cb_name, OutArg())

    __getitem__ = item


    _property_names[count] = "count"
    _property_names[_new_enum] = "_new_enum"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentCollection, [CentralBodyComponentCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5646011597072473207, 6446331028504217010), CentralBodyComponentCollection)
agcls.AgTypeNameMap["CentralBodyComponentCollection"] = CentralBodyComponentCollection

class CentralBodyComponent(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """General properties for a central body."""

    _num_methods = 41
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_gravitational_parameter_method_offset = 1
    _set_gravitational_parameter_method_offset = 2
    _get_parent_name_method_offset = 3
    _set_parent_name_method_offset = 4
    _get_children_method_offset = 5
    _get_default_gravity_model_name_method_offset = 6
    _set_default_gravity_model_by_name_method_offset = 7
    _get_default_gravity_model_data_method_offset = 8
    _add_gravity_model_method_offset = 9
    _remove_gravity_model_by_name_method_offset = 10
    _get_default_shape_name_method_offset = 11
    _get_default_shape_data_method_offset = 12
    _set_default_shape_by_name_method_offset = 13
    _add_shape_method_offset = 14
    _remove_shape_by_name_method_offset = 15
    _get_default_attitude_name_method_offset = 16
    _get_default_attitude_data_method_offset = 17
    _set_default_attitude_by_name_method_offset = 18
    _add_attitude_method_offset = 19
    _remove_attitude_by_name_method_offset = 20
    _get_default_ephemeris_name_method_offset = 21
    _set_default_ephemeris_by_name_method_offset = 22
    _get_default_ephemeris_data_method_offset = 23
    _add_ephemeris_method_offset = 24
    _remove_ephemeris_by_name_method_offset = 25
    _cut_gravity_model_by_name_method_offset = 26
    _copy_gravity_model_by_name_method_offset = 27
    _paste_gravity_model_method_offset = 28
    _add_copy_of_gravity_model_method_offset = 29
    _cut_shape_by_name_method_offset = 30
    _copy_shape_by_name_method_offset = 31
    _paste_shape_method_offset = 32
    _add_copy_of_shape_method_offset = 33
    _cut_attitude_by_name_method_offset = 34
    _copy_attitude_by_name_method_offset = 35
    _paste_attitude_method_offset = 36
    _add_copy_of_attitude_method_offset = 37
    _cut_ephemeris_by_name_method_offset = 38
    _copy_ephemeris_by_name_method_offset = 39
    _paste_ephemeris_method_offset = 40
    _add_copy_of_ephemeris_method_offset = 41
    _metadata = {
        "iid_data" : (5640221303112903926, 9492475738650464186),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponent)

    _get_gravitational_parameter_metadata = { "offset" : _get_gravitational_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def gravitational_parameter(self) -> float:
        """Get or set the gravitational parameter to be used. Uses Gravity Parameter Dimension."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_gravitational_parameter_metadata)

    _set_gravitational_parameter_metadata = { "offset" : _set_gravitational_parameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @gravitational_parameter.setter
    def gravitational_parameter(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponent._metadata, CentralBodyComponent._set_gravitational_parameter_metadata, value)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get or set the parent of this central body."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_parent_name_metadata)

    _set_parent_name_metadata = { "offset" : _set_parent_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @parent_name.setter
    def parent_name(self, value:str) -> None:
        return self._intf.set_property(CentralBodyComponent._metadata, CentralBodyComponent._set_parent_name_metadata, value)

    _get_children_metadata = { "offset" : _get_children_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def children(self) -> "CentralBodyComponentCollection":
        """Get the children of this central body."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_children_metadata)

    _get_default_gravity_model_name_metadata = { "offset" : _get_default_gravity_model_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def default_gravity_model_name(self) -> str:
        """Get the gravity model."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_gravity_model_name_metadata)

    _set_default_gravity_model_by_name_metadata = { "offset" : _set_default_gravity_model_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_default_gravity_model_by_name(self, gravity_model_name:str) -> None:
        """Select a gravity model."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._set_default_gravity_model_by_name_metadata, gravity_model_name)

    _get_default_gravity_model_data_metadata = { "offset" : _get_default_gravity_model_data_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_gravity_model_data(self) -> "CentralBodyComponentGravityModel":
        """Get the gravity model parameters."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_gravity_model_data_metadata)

    _add_gravity_model_metadata = { "offset" : _add_gravity_model_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(CentralBodyGravityModel), agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_gravity_model(self, gravity_model:"CentralBodyGravityModel", unique_name:str) -> "CentralBodyComponentGravityModel":
        """Add a central body gravity model type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_gravity_model_metadata, gravity_model, unique_name, OutArg())

    _remove_gravity_model_by_name_metadata = { "offset" : _remove_gravity_model_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_gravity_model_by_name(self, gravity_model_name:str) -> None:
        """Remove a central body gravity model type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._remove_gravity_model_by_name_metadata, gravity_model_name)

    _get_default_shape_name_metadata = { "offset" : _get_default_shape_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def default_shape_name(self) -> str:
        """Get the shape of the central body."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_shape_name_metadata)

    _get_default_shape_data_metadata = { "offset" : _get_default_shape_data_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_shape_data(self) -> "ICentralBodyComponentShape":
        """Get the parameters of the central body shape."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_shape_data_metadata)

    _set_default_shape_by_name_metadata = { "offset" : _set_default_shape_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_default_shape_by_name(self, shape_name:str) -> None:
        """Select a central body shape."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._set_default_shape_by_name_metadata, shape_name)

    _add_shape_metadata = { "offset" : _add_shape_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(CentralBodyShape), agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_shape(self, shape:"CentralBodyShape", unique_name:str) -> "ICentralBodyComponentShape":
        """Add a central body shape type from the available types."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_shape_metadata, shape, unique_name, OutArg())

    _remove_shape_by_name_metadata = { "offset" : _remove_shape_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_shape_by_name(self, shape_name:str) -> None:
        """Remove a central body shape type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._remove_shape_by_name_metadata, shape_name)

    _get_default_attitude_name_metadata = { "offset" : _get_default_attitude_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def default_attitude_name(self) -> str:
        """Get the attitude of the central body."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_attitude_name_metadata)

    _get_default_attitude_data_metadata = { "offset" : _get_default_attitude_data_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_attitude_data(self) -> "ICentralBodyComponentAttitude":
        """Get the parameters of the central body attitude."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_attitude_data_metadata)

    _set_default_attitude_by_name_metadata = { "offset" : _set_default_attitude_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_default_attitude_by_name(self, attitude_name:str) -> None:
        """Select a central body attitude."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._set_default_attitude_by_name_metadata, attitude_name)

    _add_attitude_metadata = { "offset" : _add_attitude_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(CentralBodyAttitude), agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_attitude(self, attitude:"CentralBodyAttitude", unique_name:str) -> "ICentralBodyComponentAttitude":
        """Add a central body attitude type from the available types."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_attitude_metadata, attitude, unique_name, OutArg())

    _remove_attitude_by_name_metadata = { "offset" : _remove_attitude_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_attitude_by_name(self, attitude_name:str) -> None:
        """Remove a central body attitude type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._remove_attitude_by_name_metadata, attitude_name)

    _get_default_ephemeris_name_metadata = { "offset" : _get_default_ephemeris_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def default_ephemeris_name(self) -> str:
        """Get the ephemeris of the central body."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_ephemeris_name_metadata)

    _set_default_ephemeris_by_name_metadata = { "offset" : _set_default_ephemeris_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_default_ephemeris_by_name(self, ephemeris_name:str) -> None:
        """Select an ephemeris type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._set_default_ephemeris_by_name_metadata, ephemeris_name)

    _get_default_ephemeris_data_metadata = { "offset" : _get_default_ephemeris_data_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_ephemeris_data(self) -> "ICentralBodyComponentEphemeris":
        """Get the parameters of the central body ephemeris."""
        return self._intf.get_property(CentralBodyComponent._metadata, CentralBodyComponent._get_default_ephemeris_data_metadata)

    _add_ephemeris_metadata = { "offset" : _add_ephemeris_method_offset,
            "arg_types" : (agcom.LONG, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(CentralBodyEphemeris), agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_ephemeris(self, ephemeris:"CentralBodyEphemeris", unique_name:str) -> "ICentralBodyComponentEphemeris":
        """Add an ephemeris type from the available types."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_ephemeris_metadata, ephemeris, unique_name, OutArg())

    _remove_ephemeris_by_name_metadata = { "offset" : _remove_ephemeris_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_ephemeris_by_name(self, ephemeris_name:str) -> None:
        """Remove an ephemeris type."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._remove_ephemeris_by_name_metadata, ephemeris_name)

    _cut_gravity_model_by_name_metadata = { "offset" : _cut_gravity_model_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def cut_gravity_model_by_name(self, gravity_model_name:str) -> None:
        """Copy a gravity model to the clipboard and removes it from the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._cut_gravity_model_by_name_metadata, gravity_model_name)

    _copy_gravity_model_by_name_metadata = { "offset" : _copy_gravity_model_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def copy_gravity_model_by_name(self, gravity_model_name:str) -> None:
        """Copy a gravity model to the clipboard."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._copy_gravity_model_by_name_metadata, gravity_model_name)

    _paste_gravity_model_metadata = { "offset" : _paste_gravity_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste_gravity_model(self) -> "CentralBodyComponentGravityModel":
        """Add the gravity model in the clipboard to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._paste_gravity_model_metadata, OutArg())

    _add_copy_of_gravity_model_metadata = { "offset" : _add_copy_of_gravity_model_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("CentralBodyComponentGravityModel"), agmarshall.InterfaceOutArg,) }
    def add_copy_of_gravity_model(self, gravity_model:"CentralBodyComponentGravityModel") -> "CentralBodyComponentGravityModel":
        """Add the gravity model to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_copy_of_gravity_model_metadata, gravity_model, OutArg())

    _cut_shape_by_name_metadata = { "offset" : _cut_shape_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def cut_shape_by_name(self, shape_name:str) -> None:
        """Copy a central body shape to the clipboard and removes it from the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._cut_shape_by_name_metadata, shape_name)

    _copy_shape_by_name_metadata = { "offset" : _copy_shape_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def copy_shape_by_name(self, shape_name:str) -> None:
        """Copy a central body shape to the clipboard."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._copy_shape_by_name_metadata, shape_name)

    _paste_shape_metadata = { "offset" : _paste_shape_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste_shape(self) -> "ICentralBodyComponentShape":
        """Add the central body shape in the clipboard to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._paste_shape_metadata, OutArg())

    _add_copy_of_shape_metadata = { "offset" : _add_copy_of_shape_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ICentralBodyComponentShape"), agmarshall.InterfaceOutArg,) }
    def add_copy_of_shape(self, shape:"ICentralBodyComponentShape") -> "ICentralBodyComponentShape":
        """Add the central body shape to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_copy_of_shape_metadata, shape, OutArg())

    _cut_attitude_by_name_metadata = { "offset" : _cut_attitude_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def cut_attitude_by_name(self, attitude_name:str) -> None:
        """Copy a central body attitude definition to the clipboard and removes it from the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._cut_attitude_by_name_metadata, attitude_name)

    _copy_attitude_by_name_metadata = { "offset" : _copy_attitude_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def copy_attitude_by_name(self, attitude_name:str) -> None:
        """Copy a central body attitude definition to the clipboard."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._copy_attitude_by_name_metadata, attitude_name)

    _paste_attitude_metadata = { "offset" : _paste_attitude_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste_attitude(self) -> "ICentralBodyComponentAttitude":
        """Add the central body attitude definition in the clipboard to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._paste_attitude_metadata, OutArg())

    _add_copy_of_attitude_metadata = { "offset" : _add_copy_of_attitude_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ICentralBodyComponentAttitude"), agmarshall.InterfaceOutArg,) }
    def add_copy_of_attitude(self, attitude:"ICentralBodyComponentAttitude") -> "ICentralBodyComponentAttitude":
        """Add the central body attitude definition to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_copy_of_attitude_metadata, attitude, OutArg())

    _cut_ephemeris_by_name_metadata = { "offset" : _cut_ephemeris_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def cut_ephemeris_by_name(self, ephemeris_name:str) -> None:
        """Copy a central body ephemeris definition to the clipboard and removes it from the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._cut_ephemeris_by_name_metadata, ephemeris_name)

    _copy_ephemeris_by_name_metadata = { "offset" : _copy_ephemeris_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def copy_ephemeris_by_name(self, ephemeris_name:str) -> None:
        """Copy a central body ephemeris definition to the clipboard."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._copy_ephemeris_by_name_metadata, ephemeris_name)

    _paste_ephemeris_metadata = { "offset" : _paste_ephemeris_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste_ephemeris(self) -> "ICentralBodyComponentEphemeris":
        """Add the central body ephemeris definition in the clipboard to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._paste_ephemeris_metadata, OutArg())

    _add_copy_of_ephemeris_metadata = { "offset" : _add_copy_of_ephemeris_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ICentralBodyComponentEphemeris"), agmarshall.InterfaceOutArg,) }
    def add_copy_of_ephemeris(self, ephemeris:"ICentralBodyComponentEphemeris") -> "ICentralBodyComponentEphemeris":
        """Add the central body ephemeris definition to the central body."""
        return self._intf.invoke(CentralBodyComponent._metadata, CentralBodyComponent._add_copy_of_ephemeris_metadata, ephemeris, OutArg())

    _property_names[gravitational_parameter] = "gravitational_parameter"
    _property_names[parent_name] = "parent_name"
    _property_names[children] = "children"
    _property_names[default_gravity_model_name] = "default_gravity_model_name"
    _property_names[default_gravity_model_data] = "default_gravity_model_data"
    _property_names[default_shape_name] = "default_shape_name"
    _property_names[default_shape_data] = "default_shape_data"
    _property_names[default_attitude_name] = "default_attitude_name"
    _property_names[default_attitude_data] = "default_attitude_data"
    _property_names[default_ephemeris_name] = "default_ephemeris_name"
    _property_names[default_ephemeris_data] = "default_ephemeris_data"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponent."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponent)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponent, [CentralBodyComponent, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4946042482461305423, 869776284401354677), CentralBodyComponent)
agcls.AgTypeNameMap["CentralBodyComponent"] = CentralBodyComponent

class CentralBodyComponentGravityModel(SupportsDeleteCallback):
    """Properties for a central body gravity model."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_gravitational_parameter_method_offset = 1
    _set_gravitational_parameter_method_offset = 2
    _get_reference_distance_method_offset = 3
    _set_reference_distance_method_offset = 4
    _get_j2_method_offset = 5
    _set_j2_method_offset = 6
    _get_j3_method_offset = 7
    _set_j3_method_offset = 8
    _get_j4_method_offset = 9
    _set_j4_method_offset = 10
    _metadata = {
        "iid_data" : (4697797027617980998, 12130301205692264322),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentGravityModel)

    _get_gravitational_parameter_metadata = { "offset" : _get_gravitational_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def gravitational_parameter(self) -> float:
        """Get or set the gravitational parameter to be used for purposes of this gravity model. Uses Gravitational Param Dimension."""
        return self._intf.get_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._get_gravitational_parameter_metadata)

    _set_gravitational_parameter_metadata = { "offset" : _set_gravitational_parameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @gravitational_parameter.setter
    def gravitational_parameter(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._set_gravitational_parameter_metadata, value)

    _get_reference_distance_metadata = { "offset" : _get_reference_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_distance(self) -> float:
        """Distance from the center of mass of the central body to its surface. Typically defaults to the Maximum Radius entered in the Shape frame of the Central Body parameters window. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._get_reference_distance_metadata)

    _set_reference_distance_metadata = { "offset" : _set_reference_distance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_distance.setter
    def reference_distance(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._set_reference_distance_metadata, value)

    _get_j2_metadata = { "offset" : _get_j2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def j2(self) -> float:
        """Get or set the J2 property. Taking into account first order Earth oblateness effects. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._get_j2_metadata)

    _set_j2_metadata = { "offset" : _set_j2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @j2.setter
    def j2(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._set_j2_metadata, value)

    _get_j3_metadata = { "offset" : _get_j3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def j3(self) -> float:
        """Get or set the J3 property. Taking into account first order longitudinal variations of the Earth's shape. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._get_j3_metadata)

    _set_j3_metadata = { "offset" : _set_j3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @j3.setter
    def j3(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._set_j3_metadata, value)

    _get_j4_metadata = { "offset" : _get_j4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def j4(self) -> float:
        """Get or set the J4 property. Taking into account first and second order Earth oblateness effects. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._get_j4_metadata)

    _set_j4_metadata = { "offset" : _set_j4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @j4.setter
    def j4(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentGravityModel._metadata, CentralBodyComponentGravityModel._set_j4_metadata, value)

    _property_names[gravitational_parameter] = "gravitational_parameter"
    _property_names[reference_distance] = "reference_distance"
    _property_names[j2] = "j2"
    _property_names[j3] = "j3"
    _property_names[j4] = "j4"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentGravityModel."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentGravityModel)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentGravityModel, [CentralBodyComponentGravityModel, ])

agcls.AgClassCatalog.add_catalog_entry((4821830782571341978, 6560769308725594810), CentralBodyComponentGravityModel)
agcls.AgTypeNameMap["CentralBodyComponentGravityModel"] = CentralBodyComponentGravityModel

class CentralBodyComponentShapeSphere(ICentralBodyComponentShape, SupportsDeleteCallback):
    """Properties for the central body sphere shape."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods
    _get_radius_method_offset = 1
    _set_radius_method_offset = 2
    _metadata = {
        "iid_data" : (5230758235408657690, 9823643148124119432),
        "vtable_reference" : ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentShapeSphere)

    _get_radius_metadata = { "offset" : _get_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius(self) -> float:
        """Get or set the radius. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeSphere._metadata, CentralBodyComponentShapeSphere._get_radius_metadata)

    _set_radius_metadata = { "offset" : _set_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius.setter
    def radius(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeSphere._metadata, CentralBodyComponentShapeSphere._set_radius_metadata, value)

    _property_names[radius] = "radius"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentShapeSphere."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentShapeSphere)
        ICentralBodyComponentShape.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentShape._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentShapeSphere, [CentralBodyComponentShapeSphere, ICentralBodyComponentShape])

agcls.AgClassCatalog.add_catalog_entry((5260078994854281057, 16065891516535457), CentralBodyComponentShapeSphere)
agcls.AgTypeNameMap["CentralBodyComponentShapeSphere"] = CentralBodyComponentShapeSphere

class CentralBodyComponentShapeOblateSpheroid(ICentralBodyComponentShape, SupportsDeleteCallback):
    """Properties for the central body oblate spheroid shape."""

    _num_methods = 5
    _vtable_offset = ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods
    _get_min_radius_method_offset = 1
    _set_min_radius_method_offset = 2
    _get_max_radius_method_offset = 3
    _set_max_radius_method_offset = 4
    _get_flattening_coefficient_method_offset = 5
    _metadata = {
        "iid_data" : (5485250452012065507, 14839475088817686705),
        "vtable_reference" : ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentShapeOblateSpheroid)

    _get_min_radius_metadata = { "offset" : _get_min_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_radius(self) -> float:
        """Get or set the minimum radius. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeOblateSpheroid._metadata, CentralBodyComponentShapeOblateSpheroid._get_min_radius_metadata)

    _set_min_radius_metadata = { "offset" : _set_min_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_radius.setter
    def min_radius(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeOblateSpheroid._metadata, CentralBodyComponentShapeOblateSpheroid._set_min_radius_metadata, value)

    _get_max_radius_metadata = { "offset" : _get_max_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_radius(self) -> float:
        """Get or set the maximum radius. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeOblateSpheroid._metadata, CentralBodyComponentShapeOblateSpheroid._get_max_radius_metadata)

    _set_max_radius_metadata = { "offset" : _set_max_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_radius.setter
    def max_radius(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeOblateSpheroid._metadata, CentralBodyComponentShapeOblateSpheroid._set_max_radius_metadata, value)

    _get_flattening_coefficient_metadata = { "offset" : _get_flattening_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def flattening_coefficient(self) -> float:
        """Get the flattening coefficient; automatically derived from the minimum and maximum radii. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentShapeOblateSpheroid._metadata, CentralBodyComponentShapeOblateSpheroid._get_flattening_coefficient_metadata)

    _property_names[min_radius] = "min_radius"
    _property_names[max_radius] = "max_radius"
    _property_names[flattening_coefficient] = "flattening_coefficient"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentShapeOblateSpheroid."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentShapeOblateSpheroid)
        ICentralBodyComponentShape.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentShape._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentShapeOblateSpheroid, [CentralBodyComponentShapeOblateSpheroid, ICentralBodyComponentShape])

agcls.AgClassCatalog.add_catalog_entry((5219245590015143147, 10316844097444389793), CentralBodyComponentShapeOblateSpheroid)
agcls.AgTypeNameMap["CentralBodyComponentShapeOblateSpheroid"] = CentralBodyComponentShapeOblateSpheroid

class CentralBodyComponentShapeTriaxialEllipsoid(ICentralBodyComponentShape, SupportsDeleteCallback):
    """Properties for the central body triaxial ellipsoid shape."""

    _num_methods = 6
    _vtable_offset = ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods
    _get_semimajor_axis_method_offset = 1
    _set_semimajor_axis_method_offset = 2
    _get_semimid_axis_method_offset = 3
    _set_semimid_axis_method_offset = 4
    _get_semiminor_axis_method_offset = 5
    _set_semiminor_axis_method_offset = 6
    _metadata = {
        "iid_data" : (5063152003497522251, 9401477560282307262),
        "vtable_reference" : ICentralBodyComponentShape._vtable_offset + ICentralBodyComponentShape._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentShapeTriaxialEllipsoid)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """Get or set the semi-major axis. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._set_semimajor_axis_metadata, value)

    _get_semimid_axis_metadata = { "offset" : _get_semimid_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimid_axis(self) -> float:
        """Get or set the semi-mid axis. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._get_semimid_axis_metadata)

    _set_semimid_axis_metadata = { "offset" : _set_semimid_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimid_axis.setter
    def semimid_axis(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._set_semimid_axis_metadata, value)

    _get_semiminor_axis_metadata = { "offset" : _get_semiminor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semiminor_axis(self) -> float:
        """Get or set the semi-minor axis. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._get_semiminor_axis_metadata)

    _set_semiminor_axis_metadata = { "offset" : _set_semiminor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semiminor_axis.setter
    def semiminor_axis(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentShapeTriaxialEllipsoid._metadata, CentralBodyComponentShapeTriaxialEllipsoid._set_semiminor_axis_metadata, value)

    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[semimid_axis] = "semimid_axis"
    _property_names[semiminor_axis] = "semiminor_axis"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentShapeTriaxialEllipsoid."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentShapeTriaxialEllipsoid)
        ICentralBodyComponentShape.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentShape._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentShapeTriaxialEllipsoid, [CentralBodyComponentShapeTriaxialEllipsoid, ICentralBodyComponentShape])

agcls.AgClassCatalog.add_catalog_entry((5050867345906750156, 12587040557795424178), CentralBodyComponentShapeTriaxialEllipsoid)
agcls.AgTypeNameMap["CentralBodyComponentShapeTriaxialEllipsoid"] = CentralBodyComponentShapeTriaxialEllipsoid

class CentralBodyComponentAttitudeRotationCoefficientsFile(ICentralBodyComponentAttitude, SupportsDeleteCallback):
    """Properties for a rotation coefficients file attitude definition."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentAttitude._vtable_offset + ICentralBodyComponentAttitude._num_methods
    _get_filename_method_offset = 1
    _set_filename_method_offset = 2
    _metadata = {
        "iid_data" : (5095681338417288511, 6927611188181800883),
        "vtable_reference" : ICentralBodyComponentAttitude._vtable_offset + ICentralBodyComponentAttitude._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentAttitudeRotationCoefficientsFile)

    _get_filename_metadata = { "offset" : _get_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filename(self) -> str:
        """Get or set the name of the rotation coefficients file."""
        return self._intf.get_property(CentralBodyComponentAttitudeRotationCoefficientsFile._metadata, CentralBodyComponentAttitudeRotationCoefficientsFile._get_filename_metadata)

    _set_filename_metadata = { "offset" : _set_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @filename.setter
    def filename(self, value:str) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeRotationCoefficientsFile._metadata, CentralBodyComponentAttitudeRotationCoefficientsFile._set_filename_metadata, value)

    _property_names[filename] = "filename"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentAttitudeRotationCoefficientsFile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentAttitudeRotationCoefficientsFile)
        ICentralBodyComponentAttitude.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentAttitude._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentAttitudeRotationCoefficientsFile, [CentralBodyComponentAttitudeRotationCoefficientsFile, ICentralBodyComponentAttitude])

agcls.AgClassCatalog.add_catalog_entry((4684700220808562037, 7877415965054162825), CentralBodyComponentAttitudeRotationCoefficientsFile)
agcls.AgTypeNameMap["CentralBodyComponentAttitudeRotationCoefficientsFile"] = CentralBodyComponentAttitudeRotationCoefficientsFile

class CentralBodyComponentAttitudeIAU1994(ICentralBodyComponentAttitude, SupportsDeleteCallback):
    """Properties for an IAU1994 attitude definition."""

    _num_methods = 12
    _vtable_offset = ICentralBodyComponentAttitude._vtable_offset + ICentralBodyComponentAttitude._num_methods
    _get_right_ascension_method_offset = 1
    _set_right_ascension_method_offset = 2
    _get_declination_method_offset = 3
    _set_declination_method_offset = 4
    _get_right_ascension_rate_method_offset = 5
    _set_right_ascension_rate_method_offset = 6
    _get_declination_rate_method_offset = 7
    _set_declination_rate_method_offset = 8
    _get_rotation_offset_method_offset = 9
    _set_rotation_offset_method_offset = 10
    _get_rotation_rate_method_offset = 11
    _set_rotation_rate_method_offset = 12
    _metadata = {
        "iid_data" : (5549016629518068083, 12192704956758789263),
        "vtable_reference" : ICentralBodyComponentAttitude._vtable_offset + ICentralBodyComponentAttitude._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentAttitudeIAU1994)

    _get_right_ascension_metadata = { "offset" : _get_right_ascension_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def right_ascension(self) -> typing.Any:
        """Get or set the right ascension; the angle measured in the inertial equatorial plane from the inertial X axis in a right-handed sense about the inertial Z axis to the spin axis -- the angle  in the drawing below. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_right_ascension_metadata)

    _set_right_ascension_metadata = { "offset" : _set_right_ascension_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @right_ascension.setter
    def right_ascension(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_right_ascension_metadata, value)

    _get_declination_metadata = { "offset" : _get_declination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def declination(self) -> typing.Any:
        """Get or set the declination; the angle from the X-Y plane of the coordinate system to the spin axis vector. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_declination_metadata)

    _set_declination_metadata = { "offset" : _set_declination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @declination.setter
    def declination(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_declination_metadata, value)

    _get_right_ascension_rate_metadata = { "offset" : _get_right_ascension_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def right_ascension_rate(self) -> float:
        """Get or set the right ascension rate; the rate of change in the right ascension. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_right_ascension_rate_metadata)

    _set_right_ascension_rate_metadata = { "offset" : _set_right_ascension_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @right_ascension_rate.setter
    def right_ascension_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_right_ascension_rate_metadata, value)

    _get_declination_rate_metadata = { "offset" : _get_declination_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def declination_rate(self) -> float:
        """Get or set the declination rate; the rate of change in the declination. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_declination_rate_metadata)

    _set_declination_rate_metadata = { "offset" : _set_declination_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @declination_rate.setter
    def declination_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_declination_rate_metadata, value)

    _get_rotation_offset_metadata = { "offset" : _get_rotation_offset_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def rotation_offset(self) -> typing.Any:
        """Get or set the rotation offset; the angle from the inertially fixed reference direction to the body-fixed prime meridian (0 deg longitude) at the time of epoch. Uses AngleUnit Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_rotation_offset_metadata)

    _set_rotation_offset_metadata = { "offset" : _set_rotation_offset_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @rotation_offset.setter
    def rotation_offset(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_rotation_offset_metadata, value)

    _get_rotation_rate_metadata = { "offset" : _get_rotation_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def rotation_rate(self) -> float:
        """Get or set the rotation rate; the rate of the central body's rotation. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._get_rotation_rate_metadata)

    _set_rotation_rate_metadata = { "offset" : _set_rotation_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @rotation_rate.setter
    def rotation_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentAttitudeIAU1994._metadata, CentralBodyComponentAttitudeIAU1994._set_rotation_rate_metadata, value)

    _property_names[right_ascension] = "right_ascension"
    _property_names[declination] = "declination"
    _property_names[right_ascension_rate] = "right_ascension_rate"
    _property_names[declination_rate] = "declination_rate"
    _property_names[rotation_offset] = "rotation_offset"
    _property_names[rotation_rate] = "rotation_rate"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentAttitudeIAU1994."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentAttitudeIAU1994)
        ICentralBodyComponentAttitude.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentAttitude._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentAttitudeIAU1994, [CentralBodyComponentAttitudeIAU1994, ICentralBodyComponentAttitude])

agcls.AgClassCatalog.add_catalog_entry((5033176508424437318, 9839194961858099586), CentralBodyComponentAttitudeIAU1994)
agcls.AgTypeNameMap["CentralBodyComponentAttitudeIAU1994"] = CentralBodyComponentAttitudeIAU1994

class CentralBodyComponentEphemerisAnalyticOrbit(ICentralBodyComponentEphemeris, SupportsDeleteCallback):
    """Properties for the Analytic Orbit ephemeris source."""

    _num_methods = 26
    _vtable_offset = ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods
    _get_epoch_method_offset = 1
    _set_epoch_method_offset = 2
    _get_semimajor_axis_method_offset = 3
    _set_semimajor_axis_method_offset = 4
    _get_semimajor_axis_rate_method_offset = 5
    _set_semimajor_axis_rate_method_offset = 6
    _get_eccentricity_method_offset = 7
    _set_eccentricity_method_offset = 8
    _get_eccentricity_rate_method_offset = 9
    _set_eccentricity_rate_method_offset = 10
    _get_inclination_method_offset = 11
    _set_inclination_method_offset = 12
    _get_inclination_rate_method_offset = 13
    _set_inclination_rate_method_offset = 14
    _get_raan_method_offset = 15
    _set_raan_method_offset = 16
    _get_raan_rate_method_offset = 17
    _set_raan_rate_method_offset = 18
    _get_arg_of_periapsis_method_offset = 19
    _set_arg_of_periapsis_method_offset = 20
    _get_arg_of_periapsis_rate_method_offset = 21
    _set_arg_of_periapsis_rate_method_offset = 22
    _get_mean_longitude_method_offset = 23
    _set_mean_longitude_method_offset = 24
    _get_mean_longitude_rate_method_offset = 25
    _set_mean_longitude_rate_method_offset = 26
    _metadata = {
        "iid_data" : (4753317389975628734, 12335812999387687081),
        "vtable_reference" : ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentEphemerisAnalyticOrbit)

    _get_epoch_metadata = { "offset" : _get_epoch_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def epoch(self) -> float:
        """Get or set the epoch. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_epoch_metadata)

    _set_epoch_metadata = { "offset" : _set_epoch_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @epoch.setter
    def epoch(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_epoch_metadata, value)

    _get_semimajor_axis_metadata = { "offset" : _get_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis(self) -> float:
        """Get or set the semi-major axis; one-half the distance along the long axis of the elliptical orbit. Uses Distance Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_semimajor_axis_metadata)

    _set_semimajor_axis_metadata = { "offset" : _set_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis.setter
    def semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_semimajor_axis_metadata, value)

    _get_semimajor_axis_rate_metadata = { "offset" : _get_semimajor_axis_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def semimajor_axis_rate(self) -> float:
        """Get or set the semi-major axis rate of change. Uses Rate Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_semimajor_axis_rate_metadata)

    _set_semimajor_axis_rate_metadata = { "offset" : _set_semimajor_axis_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @semimajor_axis_rate.setter
    def semimajor_axis_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_semimajor_axis_rate_metadata, value)

    _get_eccentricity_metadata = { "offset" : _get_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity(self) -> float:
        """Get or set the eccentricity; the ratio of the distance between the two foci of the ellipse and its major axis. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_eccentricity_metadata)

    _set_eccentricity_metadata = { "offset" : _set_eccentricity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @eccentricity.setter
    def eccentricity(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_eccentricity_metadata, value)

    _get_eccentricity_rate_metadata = { "offset" : _get_eccentricity_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity_rate(self) -> float:
        """Get or set the eccentricity rate of change. Dimensionless."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_eccentricity_rate_metadata)

    _set_eccentricity_rate_metadata = { "offset" : _set_eccentricity_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @eccentricity_rate.setter
    def eccentricity_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_eccentricity_rate_metadata, value)

    _get_inclination_metadata = { "offset" : _get_inclination_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inclination(self) -> typing.Any:
        """Get or set the inclination; the angle from the Z axis of the inertial coordinate system to the orbit angular velocity vector. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_inclination_metadata)

    _set_inclination_metadata = { "offset" : _set_inclination_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inclination.setter
    def inclination(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_inclination_metadata, value)

    _get_inclination_rate_metadata = { "offset" : _get_inclination_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def inclination_rate(self) -> float:
        """Get or set the inclination rate of change. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_inclination_rate_metadata)

    _set_inclination_rate_metadata = { "offset" : _set_inclination_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @inclination_rate.setter
    def inclination_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_inclination_rate_metadata, value)

    _get_raan_metadata = { "offset" : _get_raan_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def raan(self) -> typing.Any:
        """Get or set the right ascension; the angle from the X axis of the inertial coordinate system to the point where the orbit crosses the X-Y plane in the +Z direction. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_raan_metadata)

    _set_raan_metadata = { "offset" : _set_raan_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @raan.setter
    def raan(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_raan_metadata, value)

    _get_raan_rate_metadata = { "offset" : _get_raan_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def raan_rate(self) -> float:
        """Get or set the right ascension rate of change. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_raan_rate_metadata)

    _set_raan_rate_metadata = { "offset" : _set_raan_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @raan_rate.setter
    def raan_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_raan_rate_metadata, value)

    _get_arg_of_periapsis_metadata = { "offset" : _get_arg_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def arg_of_periapsis(self) -> typing.Any:
        """Get or set the argument of periapsis; The angle measured in direction of the body's orbital motion, and in the orbit plane, from the ascending node to the periapsis of the orbit. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_arg_of_periapsis_metadata)

    _set_arg_of_periapsis_metadata = { "offset" : _set_arg_of_periapsis_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @arg_of_periapsis.setter
    def arg_of_periapsis(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_arg_of_periapsis_metadata, value)

    _get_arg_of_periapsis_rate_metadata = { "offset" : _get_arg_of_periapsis_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def arg_of_periapsis_rate(self) -> float:
        """Get or set the argument of periapsis rate of change. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_arg_of_periapsis_rate_metadata)

    _set_arg_of_periapsis_rate_metadata = { "offset" : _set_arg_of_periapsis_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @arg_of_periapsis_rate.setter
    def arg_of_periapsis_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_arg_of_periapsis_rate_metadata, value)

    _get_mean_longitude_metadata = { "offset" : _get_mean_longitude_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def mean_longitude(self) -> typing.Any:
        """Get or set the mean longitude; the sum of the Right Ascension of the Ascending Node, the Argument of Periapsis and the Mean Anomaly. Uses Angle Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_mean_longitude_metadata)

    _set_mean_longitude_metadata = { "offset" : _set_mean_longitude_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @mean_longitude.setter
    def mean_longitude(self, value:typing.Any) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_mean_longitude_metadata, value)

    _get_mean_longitude_rate_metadata = { "offset" : _get_mean_longitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_longitude_rate(self) -> float:
        """Get or set the mean longitude rate of change. Uses AngleRate Dimension."""
        return self._intf.get_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._get_mean_longitude_rate_metadata)

    _set_mean_longitude_rate_metadata = { "offset" : _set_mean_longitude_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_longitude_rate.setter
    def mean_longitude_rate(self, value:float) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisAnalyticOrbit._metadata, CentralBodyComponentEphemerisAnalyticOrbit._set_mean_longitude_rate_metadata, value)

    _property_names[epoch] = "epoch"
    _property_names[semimajor_axis] = "semimajor_axis"
    _property_names[semimajor_axis_rate] = "semimajor_axis_rate"
    _property_names[eccentricity] = "eccentricity"
    _property_names[eccentricity_rate] = "eccentricity_rate"
    _property_names[inclination] = "inclination"
    _property_names[inclination_rate] = "inclination_rate"
    _property_names[raan] = "raan"
    _property_names[raan_rate] = "raan_rate"
    _property_names[arg_of_periapsis] = "arg_of_periapsis"
    _property_names[arg_of_periapsis_rate] = "arg_of_periapsis_rate"
    _property_names[mean_longitude] = "mean_longitude"
    _property_names[mean_longitude_rate] = "mean_longitude_rate"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentEphemerisAnalyticOrbit."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentEphemerisAnalyticOrbit)
        ICentralBodyComponentEphemeris.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentEphemerisAnalyticOrbit, [CentralBodyComponentEphemerisAnalyticOrbit, ICentralBodyComponentEphemeris])

agcls.AgClassCatalog.add_catalog_entry((5191484337519890481, 8136673290563576227), CentralBodyComponentEphemerisAnalyticOrbit)
agcls.AgTypeNameMap["CentralBodyComponentEphemerisAnalyticOrbit"] = CentralBodyComponentEphemerisAnalyticOrbit

class CentralBodyComponentEphemerisJPLSpice(ICentralBodyComponentEphemeris, SupportsDeleteCallback):
    """Properties for the JPL SPICE ephemeris source."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods
    _get_jpl_spice_id_method_offset = 1
    _set_jpl_spice_id_method_offset = 2
    _metadata = {
        "iid_data" : (5009289977513944391, 11298641061474462136),
        "vtable_reference" : ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentEphemerisJPLSpice)

    _get_jpl_spice_id_metadata = { "offset" : _get_jpl_spice_id_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def jpl_spice_id(self) -> str:
        """Get or set the SPICE file name."""
        return self._intf.get_property(CentralBodyComponentEphemerisJPLSpice._metadata, CentralBodyComponentEphemerisJPLSpice._get_jpl_spice_id_metadata)

    _set_jpl_spice_id_metadata = { "offset" : _set_jpl_spice_id_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @jpl_spice_id.setter
    def jpl_spice_id(self, value:str) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisJPLSpice._metadata, CentralBodyComponentEphemerisJPLSpice._set_jpl_spice_id_metadata, value)

    _property_names[jpl_spice_id] = "jpl_spice_id"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentEphemerisJPLSpice."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentEphemerisJPLSpice)
        ICentralBodyComponentEphemeris.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentEphemerisJPLSpice, [CentralBodyComponentEphemerisJPLSpice, ICentralBodyComponentEphemeris])

agcls.AgClassCatalog.add_catalog_entry((4888079214115957403, 13298646673798486434), CentralBodyComponentEphemerisJPLSpice)
agcls.AgTypeNameMap["CentralBodyComponentEphemerisJPLSpice"] = CentralBodyComponentEphemerisJPLSpice

class CentralBodyComponentEphemerisFile(ICentralBodyComponentEphemeris, SupportsDeleteCallback):
    """Properties for the Ephemeris File ephemeris source."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods
    _get_filename_method_offset = 1
    _set_filename_method_offset = 2
    _metadata = {
        "iid_data" : (5233104570870713964, 9716818812748419470),
        "vtable_reference" : ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentEphemerisFile)

    _get_filename_metadata = { "offset" : _get_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filename(self) -> str:
        """Get or set the ephemeris file name."""
        return self._intf.get_property(CentralBodyComponentEphemerisFile._metadata, CentralBodyComponentEphemerisFile._get_filename_metadata)

    _set_filename_metadata = { "offset" : _set_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @filename.setter
    def filename(self, value:str) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisFile._metadata, CentralBodyComponentEphemerisFile._set_filename_metadata, value)

    _property_names[filename] = "filename"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentEphemerisFile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentEphemerisFile)
        ICentralBodyComponentEphemeris.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentEphemerisFile, [CentralBodyComponentEphemerisFile, ICentralBodyComponentEphemeris])

agcls.AgClassCatalog.add_catalog_entry((4682194894607589662, 11232696290056966582), CentralBodyComponentEphemerisFile)
agcls.AgTypeNameMap["CentralBodyComponentEphemerisFile"] = CentralBodyComponentEphemerisFile

class CentralBodyComponentEphemerisJPLDesignExplorerOptimizer(ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides, ICentralBodyComponentEphemeris, SupportsDeleteCallback):
    """Central Body Ephemeris - JPL DE."""
    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentEphemerisJPLDesignExplorerOptimizer."""
        SupportsDeleteCallback.__init__(self)
        ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides.__init__(self, source_object)
        ICentralBodyComponentEphemeris.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides._private_init(self, intf)
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentEphemerisJPLDesignExplorerOptimizer, [ICentralBodyComponentEphemerisJPLDevelopmentalEphemerides, ICentralBodyComponentEphemeris])

agcls.AgClassCatalog.add_catalog_entry((5100712310690212330, 12064070645483617173), CentralBodyComponentEphemerisJPLDesignExplorerOptimizer)
agcls.AgTypeNameMap["CentralBodyComponentEphemerisJPLDesignExplorerOptimizer"] = CentralBodyComponentEphemerisJPLDesignExplorerOptimizer

class CentralBodyComponentEphemerisPlanetary(ICentralBodyComponentEphemeris, SupportsDeleteCallback):
    """Properties for the Planetary Ephemeris file ephemeris source."""

    _num_methods = 2
    _vtable_offset = ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods
    _get_planetary_filename_method_offset = 1
    _set_planetary_filename_method_offset = 2
    _metadata = {
        "iid_data" : (5004093576315593887, 617831019861958046),
        "vtable_reference" : ICentralBodyComponentEphemeris._vtable_offset + ICentralBodyComponentEphemeris._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CentralBodyComponentEphemerisPlanetary)

    _get_planetary_filename_metadata = { "offset" : _get_planetary_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def planetary_filename(self) -> str:
        """Get or set the planetary ephemeris file name."""
        return self._intf.get_property(CentralBodyComponentEphemerisPlanetary._metadata, CentralBodyComponentEphemerisPlanetary._get_planetary_filename_metadata)

    _set_planetary_filename_metadata = { "offset" : _set_planetary_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @planetary_filename.setter
    def planetary_filename(self, value:str) -> None:
        return self._intf.set_property(CentralBodyComponentEphemerisPlanetary._metadata, CentralBodyComponentEphemerisPlanetary._set_planetary_filename_metadata, value)

    _property_names[planetary_filename] = "planetary_filename"

    def __init__(self, source_object=None):
        """Construct an object of type CentralBodyComponentEphemerisPlanetary."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CentralBodyComponentEphemerisPlanetary)
        ICentralBodyComponentEphemeris.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICentralBodyComponentEphemeris._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CentralBodyComponentEphemerisPlanetary, [CentralBodyComponentEphemerisPlanetary, ICentralBodyComponentEphemeris])

agcls.AgClassCatalog.add_catalog_entry((4833493371149643349, 6987005291541553590), CentralBodyComponentEphemerisPlanetary)
agcls.AgTypeNameMap["CentralBodyComponentEphemerisPlanetary"] = CentralBodyComponentEphemerisPlanetary

class MCSSegmentProperties(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The segment properties."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_display_coordinate_system_method_offset = 1
    _set_display_coordinate_system_method_offset = 2
    _get_color_method_offset = 3
    _set_color_method_offset = 4
    _get_update_animation_time_after_run_method_offset = 5
    _set_update_animation_time_after_run_method_offset = 6
    _apply_final_state_to_b_planes_method_offset = 7
    _get_b_planes_method_offset = 8
    _get_last_run_code_method_offset = 9
    _metadata = {
        "iid_data" : (5508688880440286224, 5556813440259685545),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MCSSegmentProperties)

    _get_display_coordinate_system_metadata = { "offset" : _get_display_coordinate_system_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def display_coordinate_system(self) -> str:
        """Get or set the coordinate system that will be used in the segment summary report."""
        return self._intf.get_property(MCSSegmentProperties._metadata, MCSSegmentProperties._get_display_coordinate_system_metadata)

    _set_display_coordinate_system_metadata = { "offset" : _set_display_coordinate_system_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @display_coordinate_system.setter
    def display_coordinate_system(self, value:str) -> None:
        return self._intf.set_property(MCSSegmentProperties._metadata, MCSSegmentProperties._set_display_coordinate_system_metadata, value)

    _get_color_metadata = { "offset" : _get_color_method_offset,
            "arg_types" : (POINTER(agcom.OLE_COLOR),),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @property
    def color(self) -> agcolor.Color:
        """Get or set the display color of the segment."""
        return self._intf.get_property(MCSSegmentProperties._metadata, MCSSegmentProperties._get_color_metadata)

    _set_color_metadata = { "offset" : _set_color_method_offset,
            "arg_types" : (agcom.OLE_COLOR,),
            "marshallers" : (agmarshall.OLEColorArg,) }
    @color.setter
    def color(self, value:agcolor.Color) -> None:
        return self._intf.set_property(MCSSegmentProperties._metadata, MCSSegmentProperties._set_color_metadata, value)

    _get_update_animation_time_after_run_metadata = { "offset" : _get_update_animation_time_after_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def update_animation_time_after_run(self) -> bool:
        """If true, Astrogator will set the animation time to the final epoch of the segment when the segment finishes running."""
        return self._intf.get_property(MCSSegmentProperties._metadata, MCSSegmentProperties._get_update_animation_time_after_run_metadata)

    _set_update_animation_time_after_run_metadata = { "offset" : _set_update_animation_time_after_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @update_animation_time_after_run.setter
    def update_animation_time_after_run(self, value:bool) -> None:
        return self._intf.set_property(MCSSegmentProperties._metadata, MCSSegmentProperties._set_update_animation_time_after_run_metadata, value)

    _apply_final_state_to_b_planes_metadata = { "offset" : _apply_final_state_to_b_planes_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_final_state_to_b_planes(self) -> None:
        """Apply the last calculated final state of the segment to all selected B-Planes."""
        return self._intf.invoke(MCSSegmentProperties._metadata, MCSSegmentProperties._apply_final_state_to_b_planes_metadata, )

    _get_b_planes_metadata = { "offset" : _get_b_planes_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def b_planes(self) -> "BPlaneCollection":
        """Get the B-Plane or B-Planes to which the epoch, position, and velocity of the segment's final state will be applied, according to the B-Plane's definition."""
        return self._intf.get_property(MCSSegmentProperties._metadata, MCSSegmentProperties._get_b_planes_metadata)

    _get_last_run_code_metadata = { "offset" : _get_last_run_code_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RunCode),) }
    @property
    def last_run_code(self) -> "RunCode":
        """Get the last run code returned by the segment."""
        return self._intf.get_property(MCSSegmentProperties._metadata, MCSSegmentProperties._get_last_run_code_metadata)

    _property_names[display_coordinate_system] = "display_coordinate_system"
    _property_names[color] = "color"
    _property_names[update_animation_time_after_run] = "update_animation_time_after_run"
    _property_names[b_planes] = "b_planes"
    _property_names[last_run_code] = "last_run_code"

    def __init__(self, source_object=None):
        """Construct an object of type MCSSegmentProperties."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MCSSegmentProperties)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MCSSegmentProperties, [MCSSegmentProperties, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4918113374685894782, 11279002414688382869), MCSSegmentProperties)
agcls.AgTypeNameMap["MCSSegmentProperties"] = MCSSegmentProperties

class PowerInternal(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Internal Power power source component."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_generated_power_method_offset = 1
    _set_generated_power_method_offset = 2
    _get_percent_degradation_per_year_method_offset = 3
    _set_percent_degradation_per_year_method_offset = 4
    _get_reference_epoch_method_offset = 5
    _set_reference_epoch_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (5652390166041168458, 6352390215897174415),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PowerInternal)

    _get_generated_power_metadata = { "offset" : _get_generated_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def generated_power(self) -> float:
        """Get or set the power generated by the spacecraft from internal sources. Uses Power Dimension."""
        return self._intf.get_property(PowerInternal._metadata, PowerInternal._get_generated_power_metadata)

    _set_generated_power_metadata = { "offset" : _set_generated_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @generated_power.setter
    def generated_power(self, value:float) -> None:
        return self._intf.set_property(PowerInternal._metadata, PowerInternal._set_generated_power_metadata, value)

    _get_percent_degradation_per_year_metadata = { "offset" : _get_percent_degradation_per_year_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def percent_degradation_per_year(self) -> float:
        """Get or set the percent degradation per year; degradation factor is (1-x%/yr)^(timeSinceRefEpoch). Dimensionless."""
        return self._intf.get_property(PowerInternal._metadata, PowerInternal._get_percent_degradation_per_year_metadata)

    _set_percent_degradation_per_year_metadata = { "offset" : _set_percent_degradation_per_year_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @percent_degradation_per_year.setter
    def percent_degradation_per_year(self, value:float) -> None:
        return self._intf.set_property(PowerInternal._metadata, PowerInternal._set_percent_degradation_per_year_metadata, value)

    _get_reference_epoch_metadata = { "offset" : _get_reference_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def reference_epoch(self) -> typing.Any:
        """Get or set the date and Time used as reference epoch for degradation. Uses DateFormat Dimension."""
        return self._intf.get_property(PowerInternal._metadata, PowerInternal._get_reference_epoch_metadata)

    _set_reference_epoch_metadata = { "offset" : _set_reference_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @reference_epoch.setter
    def reference_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(PowerInternal._metadata, PowerInternal._set_reference_epoch_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerInternal),) }
    def enable_control_parameter(self, param:"ControlPowerInternal") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(PowerInternal._metadata, PowerInternal._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerInternal),) }
    def disable_control_parameter(self, param:"ControlPowerInternal") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(PowerInternal._metadata, PowerInternal._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlPowerInternal), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlPowerInternal") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(PowerInternal._metadata, PowerInternal._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(PowerInternal._metadata, PowerInternal._get_control_parameters_available_metadata)

    _property_names[generated_power] = "generated_power"
    _property_names[percent_degradation_per_year] = "percent_degradation_per_year"
    _property_names[reference_epoch] = "reference_epoch"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type PowerInternal."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PowerInternal)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PowerInternal, [PowerInternal, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5465081336297378060, 3548828207234260144), PowerInternal)
agcls.AgTypeNameMap["PowerInternal"] = PowerInternal

class PowerProcessed(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Processed Power power source component."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_load_method_offset = 1
    _set_load_method_offset = 2
    _get_efficiency_method_offset = 3
    _set_efficiency_method_offset = 4
    _get_input_power_source_name_method_offset = 5
    _set_input_power_source_name_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (5240984076139207842, 265208808243405979),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PowerProcessed)

    _get_load_metadata = { "offset" : _get_load_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def load(self) -> float:
        """Get or set the power diverted from power source and unavailable to PPU. Uses Power Dimension."""
        return self._intf.get_property(PowerProcessed._metadata, PowerProcessed._get_load_metadata)

    _set_load_metadata = { "offset" : _set_load_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @load.setter
    def load(self, value:float) -> None:
        return self._intf.set_property(PowerProcessed._metadata, PowerProcessed._set_load_metadata, value)

    _get_efficiency_metadata = { "offset" : _get_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def efficiency(self) -> float:
        """Get or set the efficiency of the PPU unit. Dimensionless."""
        return self._intf.get_property(PowerProcessed._metadata, PowerProcessed._get_efficiency_metadata)

    _set_efficiency_metadata = { "offset" : _set_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @efficiency.setter
    def efficiency(self, value:float) -> None:
        return self._intf.set_property(PowerProcessed._metadata, PowerProcessed._set_efficiency_metadata, value)

    _get_input_power_source_name_metadata = { "offset" : _get_input_power_source_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def input_power_source_name(self) -> str:
        """Get or set the source of power available to PPU."""
        return self._intf.get_property(PowerProcessed._metadata, PowerProcessed._get_input_power_source_name_metadata)

    _set_input_power_source_name_metadata = { "offset" : _set_input_power_source_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @input_power_source_name.setter
    def input_power_source_name(self, value:str) -> None:
        return self._intf.set_property(PowerProcessed._metadata, PowerProcessed._set_input_power_source_name_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerProcessed),) }
    def enable_control_parameter(self, param:"ControlPowerProcessed") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(PowerProcessed._metadata, PowerProcessed._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerProcessed),) }
    def disable_control_parameter(self, param:"ControlPowerProcessed") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(PowerProcessed._metadata, PowerProcessed._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlPowerProcessed), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlPowerProcessed") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(PowerProcessed._metadata, PowerProcessed._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(PowerProcessed._metadata, PowerProcessed._get_control_parameters_available_metadata)

    _property_names[load] = "load"
    _property_names[efficiency] = "efficiency"
    _property_names[input_power_source_name] = "input_power_source_name"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type PowerProcessed."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PowerProcessed)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PowerProcessed, [PowerProcessed, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5501401348525152010, 4850138180300987065), PowerProcessed)
agcls.AgTypeNameMap["PowerProcessed"] = PowerProcessed

class PowerSolarArray(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Solar Array Power power source component."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_area_method_offset = 1
    _set_area_method_offset = 2
    _get_concentration_method_offset = 3
    _set_concentration_method_offset = 4
    _get_cell_efficiency_percent_method_offset = 5
    _set_cell_efficiency_percent_method_offset = 6
    _get_array_efficiency_percent_method_offset = 7
    _set_array_efficiency_percent_method_offset = 8
    _get_percent_degradation_per_year_method_offset = 9
    _set_percent_degradation_per_year_method_offset = 10
    _get_reference_epoch_method_offset = 11
    _set_reference_epoch_method_offset = 12
    _get_inclination_to_sun_line_method_offset = 13
    _set_inclination_to_sun_line_method_offset = 14
    _get_c0_method_offset = 15
    _set_c0_method_offset = 16
    _get_c1_method_offset = 17
    _set_c1_method_offset = 18
    _get_c2_method_offset = 19
    _set_c2_method_offset = 20
    _get_c3_method_offset = 21
    _set_c3_method_offset = 22
    _get_c4_method_offset = 23
    _set_c4_method_offset = 24
    _get_approximation_formula_method_offset = 25
    _enable_control_parameter_method_offset = 26
    _disable_control_parameter_method_offset = 27
    _is_control_parameter_enabled_method_offset = 28
    _get_control_parameters_available_method_offset = 29
    _metadata = {
        "iid_data" : (5325557003361674241, 105805187980820608),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PowerSolarArray)

    _get_area_metadata = { "offset" : _get_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def area(self) -> float:
        """Get or set the solar array panel area. Uses Area Dimension."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_area_metadata)

    _set_area_metadata = { "offset" : _set_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @area.setter
    def area(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_area_metadata, value)

    _get_concentration_metadata = { "offset" : _get_concentration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def concentration(self) -> float:
        """Get or set the solar array concentrator factor. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_concentration_metadata)

    _set_concentration_metadata = { "offset" : _set_concentration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @concentration.setter
    def concentration(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_concentration_metadata, value)

    _get_cell_efficiency_percent_metadata = { "offset" : _get_cell_efficiency_percent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cell_efficiency_percent(self) -> float:
        """Get or set the cell efficiency in producing output power from incident sunlight. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_cell_efficiency_percent_metadata)

    _set_cell_efficiency_percent_metadata = { "offset" : _set_cell_efficiency_percent_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cell_efficiency_percent.setter
    def cell_efficiency_percent(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_cell_efficiency_percent_metadata, value)

    _get_array_efficiency_percent_metadata = { "offset" : _get_array_efficiency_percent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def array_efficiency_percent(self) -> float:
        """Get or set the array efficiency in producing output power from a collection of cells. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_array_efficiency_percent_metadata)

    _set_array_efficiency_percent_metadata = { "offset" : _set_array_efficiency_percent_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @array_efficiency_percent.setter
    def array_efficiency_percent(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_array_efficiency_percent_metadata, value)

    _get_percent_degradation_per_year_metadata = { "offset" : _get_percent_degradation_per_year_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def percent_degradation_per_year(self) -> float:
        """Get or set the percent degradation per year; degradation factor is (1-x%/yr)^(timeSinceRefEpoch). Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_percent_degradation_per_year_metadata)

    _set_percent_degradation_per_year_metadata = { "offset" : _set_percent_degradation_per_year_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @percent_degradation_per_year.setter
    def percent_degradation_per_year(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_percent_degradation_per_year_metadata, value)

    _get_reference_epoch_metadata = { "offset" : _get_reference_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def reference_epoch(self) -> typing.Any:
        """Get or set the date and Time used as reference epoch for degradation. Uses DateFormat Dimension."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_reference_epoch_metadata)

    _set_reference_epoch_metadata = { "offset" : _set_reference_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @reference_epoch.setter
    def reference_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_reference_epoch_metadata, value)

    _get_inclination_to_sun_line_metadata = { "offset" : _get_inclination_to_sun_line_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def inclination_to_sun_line(self) -> typing.Any:
        """Get or set the angle between the panel normal vector to the apparent sun line. Uses AngleUnit Dimension."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_inclination_to_sun_line_metadata)

    _set_inclination_to_sun_line_metadata = { "offset" : _set_inclination_to_sun_line_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @inclination_to_sun_line.setter
    def inclination_to_sun_line(self, value:typing.Any) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_inclination_to_sun_line_metadata, value)

    _get_c0_metadata = { "offset" : _get_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c0(self) -> float:
        """Get or set the ThermalModel.C0 coefficient. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_c0_metadata)

    _set_c0_metadata = { "offset" : _set_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c0.setter
    def c0(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_c0_metadata, value)

    _get_c1_metadata = { "offset" : _get_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c1(self) -> float:
        """Get or set the ThermalModel.C1 coefficient. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_c1_metadata)

    _set_c1_metadata = { "offset" : _set_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c1.setter
    def c1(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_c1_metadata, value)

    _get_c2_metadata = { "offset" : _get_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c2(self) -> float:
        """Get or set the ThermalModel.C2 coefficient. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_c2_metadata)

    _set_c2_metadata = { "offset" : _set_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c2.setter
    def c2(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_c2_metadata, value)

    _get_c3_metadata = { "offset" : _get_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c3(self) -> float:
        """Get or set the ThermalModel.C3 coefficient. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_c3_metadata)

    _set_c3_metadata = { "offset" : _set_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c3.setter
    def c3(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_c3_metadata, value)

    _get_c4_metadata = { "offset" : _get_c4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c4(self) -> float:
        """Get or set the ThermalModel.C4 coefficient. Dimensionless."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_c4_metadata)

    _set_c4_metadata = { "offset" : _set_c4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c4.setter
    def c4(self, value:float) -> None:
        return self._intf.set_property(PowerSolarArray._metadata, PowerSolarArray._set_c4_metadata, value)

    _get_approximation_formula_metadata = { "offset" : _get_approximation_formula_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def approximation_formula(self) -> str:
        """Get the thermal factor as function of distance (in AU) to Sun."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_approximation_formula_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerSolarArray),) }
    def enable_control_parameter(self, param:"ControlPowerSolarArray") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(PowerSolarArray._metadata, PowerSolarArray._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlPowerSolarArray),) }
    def disable_control_parameter(self, param:"ControlPowerSolarArray") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(PowerSolarArray._metadata, PowerSolarArray._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlPowerSolarArray), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlPowerSolarArray") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(PowerSolarArray._metadata, PowerSolarArray._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(PowerSolarArray._metadata, PowerSolarArray._get_control_parameters_available_metadata)

    _property_names[area] = "area"
    _property_names[concentration] = "concentration"
    _property_names[cell_efficiency_percent] = "cell_efficiency_percent"
    _property_names[array_efficiency_percent] = "array_efficiency_percent"
    _property_names[percent_degradation_per_year] = "percent_degradation_per_year"
    _property_names[reference_epoch] = "reference_epoch"
    _property_names[inclination_to_sun_line] = "inclination_to_sun_line"
    _property_names[c0] = "c0"
    _property_names[c1] = "c1"
    _property_names[c2] = "c2"
    _property_names[c3] = "c3"
    _property_names[c4] = "c4"
    _property_names[approximation_formula] = "approximation_formula"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type PowerSolarArray."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PowerSolarArray)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PowerSolarArray, [PowerSolarArray, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5353667160712978621, 7978587288160143028), PowerSolarArray)
agcls.AgTypeNameMap["PowerSolarArray"] = PowerSolarArray

class GeneralRelativityFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the General Relativity propagator function."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4659562620205822612, 8000868519763100309),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GeneralRelativityFunction)


    def __init__(self, source_object=None):
        """Construct an object of type GeneralRelativityFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GeneralRelativityFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GeneralRelativityFunction, [GeneralRelativityFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4643607856644942522, 666130216042495142), GeneralRelativityFunction)
agcls.AgTypeNameMap["GeneralRelativityFunction"] = GeneralRelativityFunction

class StateTransformationFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the State Transition propagator function."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5131407316737373285, 8597886627293725578),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StateTransformationFunction)


    def __init__(self, source_object=None):
        """Construct an object of type StateTransformationFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StateTransformationFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, StateTransformationFunction, [StateTransformationFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4874254178603224723, 3876770599854905017), StateTransformationFunction)
agcls.AgTypeNameMap["StateTransformationFunction"] = StateTransformationFunction

class CR3BPFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the CR3BP propagator function."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_secondary_name_method_offset = 1
    _set_secondary_name_method_offset = 2
    _get_ephemeris_epoch_method_offset = 3
    _get_eccentricity_method_offset = 4
    _get_mass_parameter_method_offset = 5
    _get_characteristic_distance_method_offset = 6
    _get_characteristic_time_method_offset = 7
    _get_characteristic_velocity_method_offset = 8
    _get_characteristic_acceleration_method_offset = 9
    _metadata = {
        "iid_data" : (4788117537309996629, 13768587730296853131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CR3BPFunction)

    _get_secondary_name_metadata = { "offset" : _get_secondary_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def secondary_name(self) -> str:
        """Get or set the secondary body  which should be consistently defined with CR3BP model definitions."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_secondary_name_metadata)

    _set_secondary_name_metadata = { "offset" : _set_secondary_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @secondary_name.setter
    def secondary_name(self, value:str) -> None:
        return self._intf.set_property(CR3BPFunction._metadata, CR3BPFunction._set_secondary_name_metadata, value)

    _get_ephemeris_epoch_metadata = { "offset" : _get_ephemeris_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def ephemeris_epoch(self) -> typing.Any:
        """Get the epoch from which the eccentricity value is reported from the secondary."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_ephemeris_epoch_metadata)

    _get_eccentricity_metadata = { "offset" : _get_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity(self) -> float:
        """Get the eccentricity at the reference epoch for the secondary's orbit."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_eccentricity_metadata)

    _get_mass_parameter_metadata = { "offset" : _get_mass_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_parameter(self) -> float:
        """Get the mass parameter computed from the primary and secondary bodies."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_mass_parameter_metadata)

    _get_characteristic_distance_metadata = { "offset" : _get_characteristic_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_distance(self) -> float:
        """Get the characteristic distance computed from the primary and secondary bodies."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_characteristic_distance_metadata)

    _get_characteristic_time_metadata = { "offset" : _get_characteristic_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_time(self) -> float:
        """Get the characteristic time computed from the primary and secondary bodies."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_characteristic_time_metadata)

    _get_characteristic_velocity_metadata = { "offset" : _get_characteristic_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_velocity(self) -> float:
        """Get the characteristic velocity computed from the primary and secondary bodies."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_characteristic_velocity_metadata)

    _get_characteristic_acceleration_metadata = { "offset" : _get_characteristic_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_acceleration(self) -> float:
        """Get the characteristic acceleration computed from the primary and secondary bodies."""
        return self._intf.get_property(CR3BPFunction._metadata, CR3BPFunction._get_characteristic_acceleration_metadata)

    _property_names[secondary_name] = "secondary_name"
    _property_names[ephemeris_epoch] = "ephemeris_epoch"
    _property_names[eccentricity] = "eccentricity"
    _property_names[mass_parameter] = "mass_parameter"
    _property_names[characteristic_distance] = "characteristic_distance"
    _property_names[characteristic_time] = "characteristic_time"
    _property_names[characteristic_velocity] = "characteristic_velocity"
    _property_names[characteristic_acceleration] = "characteristic_acceleration"

    def __init__(self, source_object=None):
        """Construct an object of type CR3BPFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CR3BPFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CR3BPFunction, [CR3BPFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4941304847140255314, 46803675568969603), CR3BPFunction)
agcls.AgTypeNameMap["CR3BPFunction"] = CR3BPFunction

class ER3BPFunc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the ER3BP propagator function."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_secondary_name_method_offset = 1
    _set_secondary_name_method_offset = 2
    _get_ephemeris_epoch_method_offset = 3
    _get_true_anomaly_method_offset = 4
    _get_eccentricity_method_offset = 5
    _get_mass_parameter_method_offset = 6
    _get_characteristic_distance_method_offset = 7
    _get_characteristic_time_method_offset = 8
    _get_characteristic_velocity_method_offset = 9
    _get_characteristic_acceleration_method_offset = 10
    _metadata = {
        "iid_data" : (4916235884320980959, 14502050449445461892),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ER3BPFunc)

    _get_secondary_name_metadata = { "offset" : _get_secondary_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def secondary_name(self) -> str:
        """Get or set the secondary body  which should be consistently defined with ER3BP model definitions."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_secondary_name_metadata)

    _set_secondary_name_metadata = { "offset" : _set_secondary_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @secondary_name.setter
    def secondary_name(self, value:str) -> None:
        return self._intf.set_property(ER3BPFunc._metadata, ER3BPFunc._set_secondary_name_metadata, value)

    _get_ephemeris_epoch_metadata = { "offset" : _get_ephemeris_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def ephemeris_epoch(self) -> typing.Any:
        """Get the epoch from which the eccentricity value is reported from the secondary."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_ephemeris_epoch_metadata)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_anomaly(self) -> typing.Any:
        """Get the true anomaly used for initializing ideal secondary."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_true_anomaly_metadata)

    _get_eccentricity_metadata = { "offset" : _get_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity(self) -> float:
        """Get the eccentricity at the reference epoch for the secondary's orbit."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_eccentricity_metadata)

    _get_mass_parameter_metadata = { "offset" : _get_mass_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_parameter(self) -> float:
        """Get the mass parameter computed from the primary and secondary bodies."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_mass_parameter_metadata)

    _get_characteristic_distance_metadata = { "offset" : _get_characteristic_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_distance(self) -> float:
        """Get the characteristic distance computed from the primary and secondary bodies."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_characteristic_distance_metadata)

    _get_characteristic_time_metadata = { "offset" : _get_characteristic_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_time(self) -> float:
        """Get the characteristic time computed from the primary and secondary bodies."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_characteristic_time_metadata)

    _get_characteristic_velocity_metadata = { "offset" : _get_characteristic_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_velocity(self) -> float:
        """Get the characteristic velocity computed from the primary and secondary bodies."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_characteristic_velocity_metadata)

    _get_characteristic_acceleration_metadata = { "offset" : _get_characteristic_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_acceleration(self) -> float:
        """Get the characteristic acceleration computed from the primary and secondary bodies."""
        return self._intf.get_property(ER3BPFunc._metadata, ER3BPFunc._get_characteristic_acceleration_metadata)

    _property_names[secondary_name] = "secondary_name"
    _property_names[ephemeris_epoch] = "ephemeris_epoch"
    _property_names[true_anomaly] = "true_anomaly"
    _property_names[eccentricity] = "eccentricity"
    _property_names[mass_parameter] = "mass_parameter"
    _property_names[characteristic_distance] = "characteristic_distance"
    _property_names[characteristic_time] = "characteristic_time"
    _property_names[characteristic_velocity] = "characteristic_velocity"
    _property_names[characteristic_acceleration] = "characteristic_acceleration"

    def __init__(self, source_object=None):
        """Construct an object of type ER3BPFunc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ER3BPFunc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ER3BPFunc, [ER3BPFunc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5726653626339621242, 11951515174846408075), ER3BPFunc)
agcls.AgTypeNameMap["ER3BPFunc"] = ER3BPFunc

class RadiationPressureFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Radiation Pressure propagator function."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_include_albedo_method_offset = 1
    _set_include_albedo_method_offset = 2
    _get_include_thermal_radiation_pressure_method_offset = 3
    _set_include_thermal_radiation_pressure_method_offset = 4
    _get_ground_reflection_model_filename_method_offset = 5
    _set_ground_reflection_model_filename_method_offset = 6
    _get_central_body_name_method_offset = 7
    _get_override_segment_settings_method_offset = 8
    _set_override_segment_settings_method_offset = 9
    _get_radiation_pressure_coefficient_method_offset = 10
    _set_radiation_pressure_coefficient_method_offset = 11
    _get_radiation_pressure_area_method_offset = 12
    _set_radiation_pressure_area_method_offset = 13
    _metadata = {
        "iid_data" : (4624530237560393103, 8957756315584128935),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RadiationPressureFunction)

    _get_include_albedo_metadata = { "offset" : _get_include_albedo_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_albedo(self) -> bool:
        """True if including accelerations derived from albedo (reflected sunlight radiation from the central body)."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_include_albedo_metadata)

    _set_include_albedo_metadata = { "offset" : _set_include_albedo_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_albedo.setter
    def include_albedo(self, value:bool) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_include_albedo_metadata, value)

    _get_include_thermal_radiation_pressure_metadata = { "offset" : _get_include_thermal_radiation_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_thermal_radiation_pressure(self) -> bool:
        """True if including accelerations derived from thermal radiation pressure from the central body."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_include_thermal_radiation_pressure_metadata)

    _set_include_thermal_radiation_pressure_metadata = { "offset" : _set_include_thermal_radiation_pressure_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_thermal_radiation_pressure.setter
    def include_thermal_radiation_pressure(self, value:bool) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_include_thermal_radiation_pressure_metadata, value)

    _get_ground_reflection_model_filename_metadata = { "offset" : _get_ground_reflection_model_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def ground_reflection_model_filename(self) -> str:
        """A file containing a ground reflection model used for albedo and thermal radiation pressure."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_ground_reflection_model_filename_metadata)

    _set_ground_reflection_model_filename_metadata = { "offset" : _set_ground_reflection_model_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @ground_reflection_model_filename.setter
    def ground_reflection_model_filename(self, value:str) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_ground_reflection_model_filename_metadata, value)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Name of the central body."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_central_body_name_metadata)

    _get_override_segment_settings_metadata = { "offset" : _get_override_segment_settings_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def override_segment_settings(self) -> bool:
        """Do not use this property, as it is deprecated. True to use Ck and area values defined on this component for radiation pressure computations, rather than those defined in the MCS segments."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_override_segment_settings_metadata)

    _set_override_segment_settings_metadata = { "offset" : _set_override_segment_settings_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @override_segment_settings.setter
    def override_segment_settings(self, value:bool) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_override_segment_settings_metadata, value)

    _get_radiation_pressure_coefficient_metadata = { "offset" : _get_radiation_pressure_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radiation_pressure_coefficient(self) -> float:
        """Do not use this property, as it is deprecated. Coefficient, Ck, for use with radiation pressure computation."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_radiation_pressure_coefficient_metadata)

    _set_radiation_pressure_coefficient_metadata = { "offset" : _set_radiation_pressure_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radiation_pressure_coefficient.setter
    def radiation_pressure_coefficient(self, value:float) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_radiation_pressure_coefficient_metadata, value)

    _get_radiation_pressure_area_metadata = { "offset" : _get_radiation_pressure_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radiation_pressure_area(self) -> float:
        """Do not use this property, as it is deprecated. Area to be used for radiation pressure computations. Small area dimension."""
        return self._intf.get_property(RadiationPressureFunction._metadata, RadiationPressureFunction._get_radiation_pressure_area_metadata)

    _set_radiation_pressure_area_metadata = { "offset" : _set_radiation_pressure_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radiation_pressure_area.setter
    def radiation_pressure_area(self, value:float) -> None:
        return self._intf.set_property(RadiationPressureFunction._metadata, RadiationPressureFunction._set_radiation_pressure_area_metadata, value)

    _property_names[include_albedo] = "include_albedo"
    _property_names[include_thermal_radiation_pressure] = "include_thermal_radiation_pressure"
    _property_names[ground_reflection_model_filename] = "ground_reflection_model_filename"
    _property_names[central_body_name] = "central_body_name"
    _property_names[override_segment_settings] = "override_segment_settings"
    _property_names[radiation_pressure_coefficient] = "radiation_pressure_coefficient"
    _property_names[radiation_pressure_area] = "radiation_pressure_area"

    def __init__(self, source_object=None):
        """Construct an object of type RadiationPressureFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RadiationPressureFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RadiationPressureFunction, [RadiationPressureFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5473529691251801248, 8545656235795709076), RadiationPressureFunction)
agcls.AgTypeNameMap["RadiationPressureFunction"] = RadiationPressureFunction

class YarkovskyFunc(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Yarkovsky Effect propagator function."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_alpha_method_offset = 1
    _set_alpha_method_offset = 2
    _get_r0_method_offset = 3
    _set_r0_method_offset = 4
    _get_nm_method_offset = 5
    _set_nm_method_offset = 6
    _get_nn_method_offset = 7
    _set_nn_method_offset = 8
    _get_nk_method_offset = 9
    _set_nk_method_offset = 10
    _get_a1_method_offset = 11
    _set_a1_method_offset = 12
    _get_a2_method_offset = 13
    _set_a2_method_offset = 14
    _get_a3_method_offset = 15
    _set_a3_method_offset = 16
    _metadata = {
        "iid_data" : (4684001781513421236, 8844314387280962446),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, YarkovskyFunc)

    _get_alpha_metadata = { "offset" : _get_alpha_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def alpha(self) -> float:
        """Yarkovsky effect alpha constant. Dimensionless."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_alpha_metadata)

    _set_alpha_metadata = { "offset" : _set_alpha_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @alpha.setter
    def alpha(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_alpha_metadata, value)

    _get_r0_metadata = { "offset" : _get_r0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def r0(self) -> float:
        """Heliocentric sublimation distance. Uses distance dimension."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_r0_metadata)

    _set_r0_metadata = { "offset" : _set_r0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @r0.setter
    def r0(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_r0_metadata, value)

    _get_nm_metadata = { "offset" : _get_nm_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nm(self) -> float:
        """Yarkovsky effect m exponent. Dimensionless."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_nm_metadata)

    _set_nm_metadata = { "offset" : _set_nm_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nm.setter
    def nm(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_nm_metadata, value)

    _get_nn_metadata = { "offset" : _get_nn_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nn(self) -> float:
        """Yarkovsky effect n exponent. Dimensionless."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_nn_metadata)

    _set_nn_metadata = { "offset" : _set_nn_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nn.setter
    def nn(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_nn_metadata, value)

    _get_nk_metadata = { "offset" : _get_nk_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nk(self) -> float:
        """Yarkovsky effect k exponent. Dimensionless."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_nk_metadata)

    _set_nk_metadata = { "offset" : _set_nk_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nk.setter
    def nk(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_nk_metadata, value)

    _get_a1_metadata = { "offset" : _get_a1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def a1(self) -> float:
        """Radial acceleration multiplier. Uses acceleration dimension."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_a1_metadata)

    _set_a1_metadata = { "offset" : _set_a1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @a1.setter
    def a1(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_a1_metadata, value)

    _get_a2_metadata = { "offset" : _get_a2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def a2(self) -> float:
        """Velocity tangent acceleration multiplier. Uses acceleration dimension."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_a2_metadata)

    _set_a2_metadata = { "offset" : _set_a2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @a2.setter
    def a2(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_a2_metadata, value)

    _get_a3_metadata = { "offset" : _get_a3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def a3(self) -> float:
        """Orbit normal acceleration multiplier. Uses acceleration dimension."""
        return self._intf.get_property(YarkovskyFunc._metadata, YarkovskyFunc._get_a3_metadata)

    _set_a3_metadata = { "offset" : _set_a3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @a3.setter
    def a3(self, value:float) -> None:
        return self._intf.set_property(YarkovskyFunc._metadata, YarkovskyFunc._set_a3_metadata, value)

    _property_names[alpha] = "alpha"
    _property_names[r0] = "r0"
    _property_names[nm] = "nm"
    _property_names[nn] = "nn"
    _property_names[nk] = "nk"
    _property_names[a1] = "a1"
    _property_names[a2] = "a2"
    _property_names[a3] = "a3"

    def __init__(self, source_object=None):
        """Construct an object of type YarkovskyFunc."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, YarkovskyFunc)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, YarkovskyFunc, [YarkovskyFunc, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5058647595155170737, 18218410163996103556), YarkovskyFunc)
agcls.AgTypeNameMap["YarkovskyFunc"] = YarkovskyFunc

class BlendedDensity(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the blended atmospheric density propagator function."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _atmos_density_model_method_offset = 1
    _low_altitude_atmosphere_density_model_method_offset = 2
    _get_density_blending_altitude_range_method_offset = 3
    _set_density_blending_altitude_range_method_offset = 4
    _get_atmos_density_model_name_method_offset = 5
    _get_low_altitude_atmosphere_density_model_name_method_offset = 6
    _get_use_approx_altitude_method_offset = 7
    _set_use_approx_altitude_method_offset = 8
    _get_lower_bound_upper_atmosphere_model_method_offset = 9
    _metadata = {
        "iid_data" : (5244451850145830949, 14069455859079753352),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BlendedDensity)

    _atmos_density_model_metadata = { "offset" : _atmos_density_model_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"),) }
    def atmos_density_model(self, value:"IComponentInfo") -> None:
        """Embeds a nominal atmosphere model from the component browser."""
        return self._intf.invoke(BlendedDensity._metadata, BlendedDensity._atmos_density_model_metadata, value)

    _low_altitude_atmosphere_density_model_metadata = { "offset" : _low_altitude_atmosphere_density_model_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"),) }
    def low_altitude_atmosphere_density_model(self, value:"IComponentInfo") -> None:
        """Embeds a low altitude atmosphere model from the component browser."""
        return self._intf.invoke(BlendedDensity._metadata, BlendedDensity._low_altitude_atmosphere_density_model_metadata, value)

    _get_density_blending_altitude_range_metadata = { "offset" : _get_density_blending_altitude_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def density_blending_altitude_range(self) -> float:
        """Get or set the blending range (distance dimension), begins at lower bound of upper model."""
        return self._intf.get_property(BlendedDensity._metadata, BlendedDensity._get_density_blending_altitude_range_metadata)

    _set_density_blending_altitude_range_metadata = { "offset" : _set_density_blending_altitude_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @density_blending_altitude_range.setter
    def density_blending_altitude_range(self, value:float) -> None:
        """Set the blending range."""
        return self._intf.set_property(BlendedDensity._metadata, BlendedDensity._set_density_blending_altitude_range_metadata, value)

    _get_atmos_density_model_name_metadata = { "offset" : _get_atmos_density_model_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmos_density_model_name(self) -> str:
        """Return the name of the embedded nominal atmospheric model."""
        return self._intf.get_property(BlendedDensity._metadata, BlendedDensity._get_atmos_density_model_name_metadata)

    _get_low_altitude_atmosphere_density_model_name_metadata = { "offset" : _get_low_altitude_atmosphere_density_model_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def low_altitude_atmosphere_density_model_name(self) -> str:
        """Return the name of the embedded low altitude atmospheric model."""
        return self._intf.get_property(BlendedDensity._metadata, BlendedDensity._get_low_altitude_atmosphere_density_model_name_metadata)

    _get_use_approx_altitude_metadata = { "offset" : _get_use_approx_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approx_altitude(self) -> bool:
        """True if using approximate altitude formula (enforced on embedded models)."""
        return self._intf.get_property(BlendedDensity._metadata, BlendedDensity._get_use_approx_altitude_metadata)

    _set_use_approx_altitude_metadata = { "offset" : _set_use_approx_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approx_altitude.setter
    def use_approx_altitude(self, value:bool) -> None:
        return self._intf.set_property(BlendedDensity._metadata, BlendedDensity._set_use_approx_altitude_metadata, value)

    _get_lower_bound_upper_atmosphere_model_metadata = { "offset" : _get_lower_bound_upper_atmosphere_model_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lower_bound_upper_atmosphere_model(self) -> float:
        """Get the lowest valid altitude of the upper atmospheric density model."""
        return self._intf.get_property(BlendedDensity._metadata, BlendedDensity._get_lower_bound_upper_atmosphere_model_metadata)

    _property_names[density_blending_altitude_range] = "density_blending_altitude_range"
    _property_names[atmos_density_model_name] = "atmos_density_model_name"
    _property_names[low_altitude_atmosphere_density_model_name] = "low_altitude_atmosphere_density_model_name"
    _property_names[use_approx_altitude] = "use_approx_altitude"
    _property_names[lower_bound_upper_atmosphere_model] = "lower_bound_upper_atmosphere_model"

    def __init__(self, source_object=None):
        """Construct an object of type BlendedDensity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BlendedDensity)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BlendedDensity, [BlendedDensity, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5152213418662569854, 18232289047425381262), BlendedDensity)
agcls.AgTypeNameMap["BlendedDensity"] = BlendedDensity

class Cira72Function(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the CIRA 72 atmospheric model."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5152253422484607359, 16481737616952338560),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Cira72Function)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate of geomagnetic flux values from the flux file."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Flux file."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(Cira72Function._metadata, Cira72Function._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(Cira72Function._metadata, Cira72Function._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type Cira72Function."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Cira72Function)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Cira72Function, [Cira72Function, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5681925775911183309, 3648980167297143424), Cira72Function)
agcls.AgTypeNameMap["Cira72Function"] = Cira72Function

class Exponential(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Exponential atmospheric model - a model that calculates atmospheric density using an equation involving a reference density, reference altitude, and scale altitude."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_reference_density_method_offset = 3
    _set_reference_density_method_offset = 4
    _get_reference_altitude_method_offset = 5
    _set_reference_altitude_method_offset = 6
    _get_scale_altitude_method_offset = 7
    _set_scale_altitude_method_offset = 8
    _get_drag_model_type_method_offset = 9
    _set_drag_model_type_method_offset = 10
    _get_drag_model_plugin_name_method_offset = 11
    _set_drag_model_plugin_name_method_offset = 12
    _get_drag_model_plugin_method_offset = 13
    _get_variable_area_history_file_method_offset = 14
    _set_variable_area_history_file_method_offset = 15
    _get_n_plate_definition_file_method_offset = 16
    _set_n_plate_definition_file_method_offset = 17
    _metadata = {
        "iid_data" : (5059873297206571404, 13470177470048636560),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Exponential)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_use_approximate_altitude_metadata, value)

    _get_reference_density_metadata = { "offset" : _get_reference_density_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_density(self) -> float:
        """Get or set the reference density. Uses Density Dimension."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_reference_density_metadata)

    _set_reference_density_metadata = { "offset" : _set_reference_density_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_density.setter
    def reference_density(self, value:float) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_reference_density_metadata, value)

    _get_reference_altitude_metadata = { "offset" : _get_reference_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_altitude(self) -> float:
        """Get or set the reference altitude. Uses Distance Dimension."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_reference_altitude_metadata)

    _set_reference_altitude_metadata = { "offset" : _set_reference_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_altitude.setter
    def reference_altitude(self, value:float) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_reference_altitude_metadata, value)

    _get_scale_altitude_metadata = { "offset" : _get_scale_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def scale_altitude(self) -> float:
        """Get or set the scale altitude. Uses Distance Dimension."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_scale_altitude_metadata)

    _set_scale_altitude_metadata = { "offset" : _set_scale_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @scale_altitude.setter
    def scale_altitude(self, value:float) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_scale_altitude_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(Exponential._metadata, Exponential._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(Exponential._metadata, Exponential._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[reference_density] = "reference_density"
    _property_names[reference_altitude] = "reference_altitude"
    _property_names[scale_altitude] = "scale_altitude"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type Exponential."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Exponential)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Exponential, [Exponential, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5550718488581795108, 206791106109717402), Exponential)
agcls.AgTypeNameMap["Exponential"] = Exponential

class HarrisPriester(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Harris-Priester atmospheric model - a model that takes into account a 10.7 cm solar flux level and diurnal bulge."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_avg_method_offset = 9
    _set_f_10_p7_avg_method_offset = 10
    _get_atmosphere_data_filename_method_offset = 11
    _set_atmosphere_data_filename_method_offset = 12
    _get_drag_model_type_method_offset = 13
    _set_drag_model_type_method_offset = 14
    _get_drag_model_plugin_name_method_offset = 15
    _set_drag_model_plugin_name_method_offset = 16
    _get_drag_model_plugin_method_offset = 17
    _get_variable_area_history_file_method_offset = 18
    _set_variable_area_history_file_method_offset = 19
    _get_n_plate_definition_file_method_offset = 20
    _set_n_plate_definition_file_method_offset = 21
    _metadata = {
        "iid_data" : (5255750643745887133, 6365549969115673235),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, HarrisPriester)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_f_10_p7_avg_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Flux file."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(HarrisPriester._metadata, HarrisPriester._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(HarrisPriester._metadata, HarrisPriester._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type HarrisPriester."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, HarrisPriester)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, HarrisPriester, [HarrisPriester, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5093587573188984474, 9935500784277497264), HarrisPriester)
agcls.AgTypeNameMap["HarrisPriester"] = HarrisPriester

class DensityModelPlugin(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the plugin atmospheric density model."""

    _num_methods = 51
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_plugin_identifier_method_offset = 1
    _set_plugin_identifier_method_offset = 2
    _get_plugin_config_method_offset = 3
    _get_use_approximate_altitude_method_offset = 4
    _set_use_approximate_altitude_method_offset = 5
    _get_computes_temperature_method_offset = 6
    _get_computes_pressure_method_offset = 7
    _get_sun_position_method_offset = 8
    _set_sun_position_method_offset = 9
    _get_atmosphere_data_source_method_offset = 10
    _set_atmosphere_data_source_method_offset = 11
    _get_f10_method_offset = 12
    _set_f10_method_offset = 13
    _get_f10_avg_method_offset = 14
    _set_f10_avg_method_offset = 15
    _get_m10_method_offset = 16
    _set_m10_method_offset = 17
    _get_m10_avg_method_offset = 18
    _set_m10_avg_method_offset = 19
    _get_s10_method_offset = 20
    _set_s10_method_offset = 21
    _get_s10_avg_method_offset = 22
    _set_s10_avg_method_offset = 23
    _get_y10_method_offset = 24
    _set_y10_method_offset = 25
    _get_y10_avg_method_offset = 26
    _set_y10_avg_method_offset = 27
    _get_kp_method_offset = 28
    _set_kp_method_offset = 29
    _get_dst_d_tc_method_offset = 30
    _set_dst_d_tc_method_offset = 31
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 32
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 33
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 34
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 35
    _get_atmosphere_data_filename_method_offset = 36
    _set_atmosphere_data_filename_method_offset = 37
    _get_atmosphere_aug_data_file_method_offset = 38
    _set_atmosphere_aug_data_file_method_offset = 39
    _get_atmosphere_aug_dtc_file_method_offset = 40
    _set_atmosphere_aug_dtc_file_method_offset = 41
    _get_drag_model_type_method_offset = 42
    _set_drag_model_type_method_offset = 43
    _get_drag_model_plugin_name_method_offset = 44
    _set_drag_model_plugin_name_method_offset = 45
    _get_drag_model_plugin_method_offset = 46
    _get_uses_augmented_space_weather_method_offset = 47
    _get_variable_area_history_file_method_offset = 48
    _set_variable_area_history_file_method_offset = 49
    _get_n_plate_definition_file_method_offset = 50
    _set_n_plate_definition_file_method_offset = 51
    _metadata = {
        "iid_data" : (5705131430047656123, 17604384030395133073),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DensityModelPlugin)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the plugin name."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_plugin_config_metadata)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_data_source_metadata, value)

    _get_f10_metadata = { "offset" : _get_f10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f10(self) -> float:
        """Solar Flux (F10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_f10_metadata)

    _set_f10_metadata = { "offset" : _set_f10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f10.setter
    def f10(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_f10_metadata, value)

    _get_f10_avg_metadata = { "offset" : _get_f10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f10_avg(self) -> float:
        """Average solar Flux (F10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_f10_avg_metadata)

    _set_f10_avg_metadata = { "offset" : _set_f10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f10_avg.setter
    def f10_avg(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_f10_avg_metadata, value)

    _get_m10_metadata = { "offset" : _get_m10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def m10(self) -> float:
        """Solar Flux (M10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_m10_metadata)

    _set_m10_metadata = { "offset" : _set_m10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @m10.setter
    def m10(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_m10_metadata, value)

    _get_m10_avg_metadata = { "offset" : _get_m10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def m10_avg(self) -> float:
        """Average solar Flux (M10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_m10_avg_metadata)

    _set_m10_avg_metadata = { "offset" : _set_m10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @m10_avg.setter
    def m10_avg(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_m10_avg_metadata, value)

    _get_s10_metadata = { "offset" : _get_s10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s10(self) -> float:
        """Solar Flux (S10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_s10_metadata)

    _set_s10_metadata = { "offset" : _set_s10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s10.setter
    def s10(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_s10_metadata, value)

    _get_s10_avg_metadata = { "offset" : _get_s10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s10_avg(self) -> float:
        """Average solar Flux (S10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_s10_avg_metadata)

    _set_s10_avg_metadata = { "offset" : _set_s10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s10_avg.setter
    def s10_avg(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_s10_avg_metadata, value)

    _get_y10_metadata = { "offset" : _get_y10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y10(self) -> float:
        """Solar Flux (Y10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_y10_metadata)

    _set_y10_metadata = { "offset" : _set_y10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y10.setter
    def y10(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_y10_metadata, value)

    _get_y10_avg_metadata = { "offset" : _get_y10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y10_avg(self) -> float:
        """Average solar Flux (Y10). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_y10_avg_metadata)

    _set_y10_avg_metadata = { "offset" : _set_y10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y10_avg.setter
    def y10_avg(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_y10_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_kp_metadata, value)

    _get_dst_d_tc_metadata = { "offset" : _get_dst_d_tc_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def dst_d_tc(self) -> float:
        """Temperature change calculated from disturbance storm time (DstDTc). Dimensionless."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_dst_d_tc_metadata)

    _set_dst_d_tc_metadata = { "offset" : _set_dst_d_tc_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @dst_d_tc.setter
    def dst_d_tc(self, value:float) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_dst_d_tc_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_data_filename_metadata, value)

    _get_atmosphere_aug_data_file_metadata = { "offset" : _get_atmosphere_aug_data_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_aug_data_file(self) -> str:
        """Get or set the atmospheric model augmented data file path."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_aug_data_file_metadata)

    _set_atmosphere_aug_data_file_metadata = { "offset" : _set_atmosphere_aug_data_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_aug_data_file.setter
    def atmosphere_aug_data_file(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_aug_data_file_metadata, value)

    _get_atmosphere_aug_dtc_file_metadata = { "offset" : _get_atmosphere_aug_dtc_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_aug_dtc_file(self) -> str:
        """Get or set the atmospheric model augmented geomagnetic data file path."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_atmosphere_aug_dtc_file_metadata)

    _set_atmosphere_aug_dtc_file_metadata = { "offset" : _set_atmosphere_aug_dtc_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_aug_dtc_file.setter
    def atmosphere_aug_dtc_file(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_atmosphere_aug_dtc_file_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_drag_model_plugin_metadata)

    _get_uses_augmented_space_weather_metadata = { "offset" : _get_uses_augmented_space_weather_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def uses_augmented_space_weather(self) -> bool:
        """Flag indicates whether this model uses augmented flux data."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_uses_augmented_space_weather_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(DensityModelPlugin._metadata, DensityModelPlugin._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(DensityModelPlugin._metadata, DensityModelPlugin._set_n_plate_definition_file_metadata, value)

    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"
    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f10] = "f10"
    _property_names[f10_avg] = "f10_avg"
    _property_names[m10] = "m10"
    _property_names[m10_avg] = "m10_avg"
    _property_names[s10] = "s10"
    _property_names[s10_avg] = "s10_avg"
    _property_names[y10] = "y10"
    _property_names[y10_avg] = "y10_avg"
    _property_names[kp] = "kp"
    _property_names[dst_d_tc] = "dst_d_tc"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[atmosphere_aug_data_file] = "atmosphere_aug_data_file"
    _property_names[atmosphere_aug_dtc_file] = "atmosphere_aug_dtc_file"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[uses_augmented_space_weather] = "uses_augmented_space_weather"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type DensityModelPlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DensityModelPlugin)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DensityModelPlugin, [DensityModelPlugin, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5046586733109563435, 8001179388313593535), DensityModelPlugin)
agcls.AgTypeNameMap["DensityModelPlugin"] = DensityModelPlugin

class JacchiaRoberts(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Jacchia-Roberts atmospheric model - a model that is similar to Jacchia 1971 but uses analytical methods to improve performance."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (4983125570264378135, 7298657247116678060),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, JacchiaRoberts)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(JacchiaRoberts._metadata, JacchiaRoberts._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaRoberts._metadata, JacchiaRoberts._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type JacchiaRoberts."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, JacchiaRoberts)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, JacchiaRoberts, [JacchiaRoberts, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5455487054666773857, 8304942187827049896), JacchiaRoberts)
agcls.AgTypeNameMap["JacchiaRoberts"] = JacchiaRoberts

class JacchiaBowman2008(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Jacchia Bowman 2008 atmospheric density model."""

    _num_methods = 37
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_sun_position_method_offset = 3
    _set_sun_position_method_offset = 4
    _get_atmosphere_data_source_method_offset = 5
    _set_atmosphere_data_source_method_offset = 6
    _get_f10_method_offset = 7
    _set_f10_method_offset = 8
    _get_f10_avg_method_offset = 9
    _set_f10_avg_method_offset = 10
    _get_m10_method_offset = 11
    _set_m10_method_offset = 12
    _get_m10_avg_method_offset = 13
    _set_m10_avg_method_offset = 14
    _get_s10_method_offset = 15
    _set_s10_method_offset = 16
    _get_s10_avg_method_offset = 17
    _set_s10_avg_method_offset = 18
    _get_y10_method_offset = 19
    _set_y10_method_offset = 20
    _get_y10_avg_method_offset = 21
    _set_y10_avg_method_offset = 22
    _get_dst_d_tc_method_offset = 23
    _set_dst_d_tc_method_offset = 24
    _get_atmosphere_aug_data_file_method_offset = 25
    _set_atmosphere_aug_data_file_method_offset = 26
    _get_atmosphere_aug_dtc_file_method_offset = 27
    _set_atmosphere_aug_dtc_file_method_offset = 28
    _get_drag_model_type_method_offset = 29
    _set_drag_model_type_method_offset = 30
    _get_drag_model_plugin_name_method_offset = 31
    _set_drag_model_plugin_name_method_offset = 32
    _get_drag_model_plugin_method_offset = 33
    _get_variable_area_history_file_method_offset = 34
    _set_variable_area_history_file_method_offset = 35
    _get_n_plate_definition_file_method_offset = 36
    _set_n_plate_definition_file_method_offset = 37
    _metadata = {
        "iid_data" : (5665147081106925816, 11481279672929475993),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, JacchiaBowman2008)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_use_approximate_altitude_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_atmosphere_data_source_metadata, value)

    _get_f10_metadata = { "offset" : _get_f10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f10(self) -> float:
        """Solar Flux (F10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_f10_metadata)

    _set_f10_metadata = { "offset" : _set_f10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f10.setter
    def f10(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_f10_metadata, value)

    _get_f10_avg_metadata = { "offset" : _get_f10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f10_avg(self) -> float:
        """Average solar Flux (F10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_f10_avg_metadata)

    _set_f10_avg_metadata = { "offset" : _set_f10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f10_avg.setter
    def f10_avg(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_f10_avg_metadata, value)

    _get_m10_metadata = { "offset" : _get_m10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def m10(self) -> float:
        """Solar Flux (M10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_m10_metadata)

    _set_m10_metadata = { "offset" : _set_m10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @m10.setter
    def m10(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_m10_metadata, value)

    _get_m10_avg_metadata = { "offset" : _get_m10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def m10_avg(self) -> float:
        """Average solar Flux (M10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_m10_avg_metadata)

    _set_m10_avg_metadata = { "offset" : _set_m10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @m10_avg.setter
    def m10_avg(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_m10_avg_metadata, value)

    _get_s10_metadata = { "offset" : _get_s10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s10(self) -> float:
        """Solar Flux (S10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_s10_metadata)

    _set_s10_metadata = { "offset" : _set_s10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s10.setter
    def s10(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_s10_metadata, value)

    _get_s10_avg_metadata = { "offset" : _get_s10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s10_avg(self) -> float:
        """Average solar Flux (S10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_s10_avg_metadata)

    _set_s10_avg_metadata = { "offset" : _set_s10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s10_avg.setter
    def s10_avg(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_s10_avg_metadata, value)

    _get_y10_metadata = { "offset" : _get_y10_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y10(self) -> float:
        """Solar Flux (Y10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_y10_metadata)

    _set_y10_metadata = { "offset" : _set_y10_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y10.setter
    def y10(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_y10_metadata, value)

    _get_y10_avg_metadata = { "offset" : _get_y10_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def y10_avg(self) -> float:
        """Average solar Flux (Y10). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_y10_avg_metadata)

    _set_y10_avg_metadata = { "offset" : _set_y10_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @y10_avg.setter
    def y10_avg(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_y10_avg_metadata, value)

    _get_dst_d_tc_metadata = { "offset" : _get_dst_d_tc_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def dst_d_tc(self) -> float:
        """Temperature change calculated from disturbance storm time (DstDTc). Dimensionless."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_dst_d_tc_metadata)

    _set_dst_d_tc_metadata = { "offset" : _set_dst_d_tc_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @dst_d_tc.setter
    def dst_d_tc(self, value:float) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_dst_d_tc_metadata, value)

    _get_atmosphere_aug_data_file_metadata = { "offset" : _get_atmosphere_aug_data_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_aug_data_file(self) -> str:
        """Get or set the atmospheric model space weather data file path."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_atmosphere_aug_data_file_metadata)

    _set_atmosphere_aug_data_file_metadata = { "offset" : _set_atmosphere_aug_data_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_aug_data_file.setter
    def atmosphere_aug_data_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_atmosphere_aug_data_file_metadata, value)

    _get_atmosphere_aug_dtc_file_metadata = { "offset" : _get_atmosphere_aug_dtc_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_aug_dtc_file(self) -> str:
        """Get or set the atmospheric model DTC file path."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_atmosphere_aug_dtc_file_metadata)

    _set_atmosphere_aug_dtc_file_metadata = { "offset" : _set_atmosphere_aug_dtc_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_aug_dtc_file.setter
    def atmosphere_aug_dtc_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_atmosphere_aug_dtc_file_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(JacchiaBowman2008._metadata, JacchiaBowman2008._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(JacchiaBowman2008._metadata, JacchiaBowman2008._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f10] = "f10"
    _property_names[f10_avg] = "f10_avg"
    _property_names[m10] = "m10"
    _property_names[m10_avg] = "m10_avg"
    _property_names[s10] = "s10"
    _property_names[s10_avg] = "s10_avg"
    _property_names[y10] = "y10"
    _property_names[y10_avg] = "y10_avg"
    _property_names[dst_d_tc] = "dst_d_tc"
    _property_names[atmosphere_aug_data_file] = "atmosphere_aug_data_file"
    _property_names[atmosphere_aug_dtc_file] = "atmosphere_aug_dtc_file"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type JacchiaBowman2008."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, JacchiaBowman2008)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, JacchiaBowman2008, [JacchiaBowman2008, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5206262767115704697, 387730423990499725), JacchiaBowman2008)
agcls.AgTypeNameMap["JacchiaBowman2008"] = JacchiaBowman2008

class Jacchia1960(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Jacchia 1960 atmospheric model - an outdated atmospheric model provided for making comparisons with other software."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_drag_model_type_method_offset = 7
    _set_drag_model_type_method_offset = 8
    _get_drag_model_plugin_name_method_offset = 9
    _set_drag_model_plugin_name_method_offset = 10
    _get_drag_model_plugin_method_offset = 11
    _get_variable_area_history_file_method_offset = 12
    _set_variable_area_history_file_method_offset = 13
    _get_n_plate_definition_file_method_offset = 14
    _set_n_plate_definition_file_method_offset = 15
    _metadata = {
        "iid_data" : (5554672196080858836, 7507800005250584450),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Jacchia1960)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_sun_position_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(Jacchia1960._metadata, Jacchia1960._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1960._metadata, Jacchia1960._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type Jacchia1960."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Jacchia1960)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Jacchia1960, [Jacchia1960, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5574385053179570645, 3116739936857571001), Jacchia1960)
agcls.AgTypeNameMap["Jacchia1960"] = Jacchia1960

class Jacchia1970(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Jacchia 1970 atmospheric model - a model that computes atmospheric density based on the composition of the atmosphere, which depends on altitude as well as seasonal variation. Valid range is 100-2500 km."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5441460915826898670, 17669561608188722089),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Jacchia1970)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(Jacchia1970._metadata, Jacchia1970._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1970._metadata, Jacchia1970._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type Jacchia1970."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Jacchia1970)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Jacchia1970, [Jacchia1970, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5341959456453390148, 8490840023175055767), Jacchia1970)
agcls.AgTypeNameMap["Jacchia1970"] = Jacchia1970

class Jacchia1971(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Jacchia 1971 atmospheric model - a model that is similar to Jacchia 1970, with improved treatment of certain solar effects."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5408607305502071766, 662924465356789944),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Jacchia1971)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(Jacchia1971._metadata, Jacchia1971._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(Jacchia1971._metadata, Jacchia1971._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type Jacchia1971."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Jacchia1971)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Jacchia1971, [Jacchia1971, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5604186918179814220, 16696022812635360702), Jacchia1971)
agcls.AgTypeNameMap["Jacchia1971"] = Jacchia1971

class MSISE1990(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the MSISE 1990 atmospheric model - an empirical density model developed by Hedin based on satellite data. Finds the total density by accounting for the contribution of N2, O, O2, He, Ar and H. 1990 version, valid range of 0-1000 km."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5636554266143253155, 3500985540569343391),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MSISE1990)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MSISE1990._metadata, MSISE1990._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MSISE1990._metadata, MSISE1990._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MSISE1990."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MSISE1990)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MSISE1990, [MSISE1990, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5340586931034210800, 11328105258405005975), MSISE1990)
agcls.AgTypeNameMap["MSISE1990"] = MSISE1990

class MSIS1986(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the MSIS 1986 atmospheric model - an empirical density model developed by Hedin based on satellite data. Finds the total density by accounting for the contribution of N2, O, O2, He, Ar and H. 1986 version, valid range of 90-1000 km."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5417413885783215747, 17139870058847460272),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MSIS1986)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MSIS1986._metadata, MSIS1986._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MSIS1986._metadata, MSIS1986._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MSIS1986."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MSIS1986)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MSIS1986, [MSIS1986, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5240601690300521833, 8211112362243914380), MSIS1986)
agcls.AgTypeNameMap["MSIS1986"] = MSIS1986

class NRLMSISE2000(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the NRLMSISE 2000 atmospheric model."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_method_offset = 9
    _set_f_10_p7_method_offset = 10
    _get_f_10_p7_avg_method_offset = 11
    _set_f_10_p7_avg_method_offset = 12
    _get_kp_method_offset = 13
    _set_kp_method_offset = 14
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 15
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 16
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 17
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 18
    _get_atmosphere_data_filename_method_offset = 19
    _set_atmosphere_data_filename_method_offset = 20
    _get_drag_model_type_method_offset = 21
    _set_drag_model_type_method_offset = 22
    _get_drag_model_plugin_name_method_offset = 23
    _set_drag_model_plugin_name_method_offset = 24
    _get_drag_model_plugin_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (4640806513605789872, 4409086059583600283),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, NRLMSISE2000)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_f_10_p7_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_f_10_p7_avg_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate for geomagnetic flux values from the flux file."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(NRLMSISE2000._metadata, NRLMSISE2000._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(NRLMSISE2000._metadata, NRLMSISE2000._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type NRLMSISE2000."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, NRLMSISE2000)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, NRLMSISE2000, [NRLMSISE2000, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5294825104791739528, 9342049865198485677), NRLMSISE2000)
agcls.AgTypeNameMap["NRLMSISE2000"] = NRLMSISE2000

class USStandardAtmosphere(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the US Standard Atmosphere atmospheric model."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_drag_model_type_method_offset = 5
    _set_drag_model_type_method_offset = 6
    _get_drag_model_plugin_name_method_offset = 7
    _set_drag_model_plugin_name_method_offset = 8
    _get_drag_model_plugin_method_offset = 9
    _get_variable_area_history_file_method_offset = 10
    _set_variable_area_history_file_method_offset = 11
    _get_n_plate_definition_file_method_offset = 12
    _set_n_plate_definition_file_method_offset = 13
    _metadata = {
        "iid_data" : (5557239014813622132, 16881112267738503602),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, USStandardAtmosphere)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(USStandardAtmosphere._metadata, USStandardAtmosphere._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_computes_pressure_metadata)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(USStandardAtmosphere._metadata, USStandardAtmosphere._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(USStandardAtmosphere._metadata, USStandardAtmosphere._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(USStandardAtmosphere._metadata, USStandardAtmosphere._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(USStandardAtmosphere._metadata, USStandardAtmosphere._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(USStandardAtmosphere._metadata, USStandardAtmosphere._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type USStandardAtmosphere."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, USStandardAtmosphere)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, USStandardAtmosphere, [USStandardAtmosphere, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4819330301504343063, 7573866645070409350), USStandardAtmosphere)
agcls.AgTypeNameMap["USStandardAtmosphere"] = USStandardAtmosphere

class MarsGRAM37(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Mars-GRAM 3.7 atmospheric model."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_data_directory_method_offset = 7
    _set_data_directory_method_offset = 8
    _get_namelist_file_method_offset = 9
    _set_namelist_file_method_offset = 10
    _get_density_type_method_offset = 11
    _set_density_type_method_offset = 12
    _get_atmosphere_data_source_method_offset = 13
    _set_atmosphere_data_source_method_offset = 14
    _get_f_10_p7_method_offset = 15
    _set_f_10_p7_method_offset = 16
    _get_atmosphere_data_filename_method_offset = 17
    _set_atmosphere_data_filename_method_offset = 18
    _get_drag_model_type_method_offset = 19
    _set_drag_model_type_method_offset = 20
    _get_drag_model_plugin_name_method_offset = 21
    _set_drag_model_plugin_name_method_offset = 22
    _get_drag_model_plugin_method_offset = 23
    _get_variable_area_history_file_method_offset = 24
    _set_variable_area_history_file_method_offset = 25
    _get_n_plate_definition_file_method_offset = 26
    _set_n_plate_definition_file_method_offset = 27
    _metadata = {
        "iid_data" : (5087150452233303935, 8220219674985455019),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MarsGRAM37)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_sun_position_metadata, value)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Full path of namelist file."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @property
    def density_type(self) -> "MarsGRAMDensityType":
        """Low, mean or high density type."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"MarsGRAMDensityType") -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_density_type_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_f_10_p7_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MarsGRAM37._metadata, MarsGRAM37._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM37._metadata, MarsGRAM37._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MarsGRAM37."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MarsGRAM37)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MarsGRAM37, [MarsGRAM37, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4904421314534157961, 5291700957109454500), MarsGRAM37)
agcls.AgTypeNameMap["MarsGRAM37"] = MarsGRAM37

class MarsGRAM2000(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Mars-GRAM 2000 atmospheric model."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_data_directory_method_offset = 7
    _set_data_directory_method_offset = 8
    _get_namelist_file_method_offset = 9
    _set_namelist_file_method_offset = 10
    _get_density_type_method_offset = 11
    _set_density_type_method_offset = 12
    _get_atmosphere_data_source_method_offset = 13
    _set_atmosphere_data_source_method_offset = 14
    _get_f_10_p7_method_offset = 15
    _set_f_10_p7_method_offset = 16
    _get_atmosphere_data_filename_method_offset = 17
    _set_atmosphere_data_filename_method_offset = 18
    _get_drag_model_type_method_offset = 19
    _set_drag_model_type_method_offset = 20
    _get_drag_model_plugin_name_method_offset = 21
    _set_drag_model_plugin_name_method_offset = 22
    _get_drag_model_plugin_method_offset = 23
    _get_variable_area_history_file_method_offset = 24
    _set_variable_area_history_file_method_offset = 25
    _get_n_plate_definition_file_method_offset = 26
    _set_n_plate_definition_file_method_offset = 27
    _metadata = {
        "iid_data" : (5292965060560654168, 16114187966956624542),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MarsGRAM2000)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_sun_position_metadata, value)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Full path of namelist file."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @property
    def density_type(self) -> "MarsGRAMDensityType":
        """Low, mean, high or randomly perturbed density type."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"MarsGRAMDensityType") -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_density_type_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_f_10_p7_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MarsGRAM2000._metadata, MarsGRAM2000._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2000._metadata, MarsGRAM2000._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MarsGRAM2000."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MarsGRAM2000)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MarsGRAM2000, [MarsGRAM2000, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5732957462272778606, 18167520949376527757), MarsGRAM2000)
agcls.AgTypeNameMap["MarsGRAM2000"] = MarsGRAM2000

class MarsGRAM2001(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Mars-GRAM 2001 atmospheric model."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_data_directory_method_offset = 7
    _set_data_directory_method_offset = 8
    _get_namelist_file_method_offset = 9
    _set_namelist_file_method_offset = 10
    _get_density_type_method_offset = 11
    _set_density_type_method_offset = 12
    _get_atmosphere_data_source_method_offset = 13
    _set_atmosphere_data_source_method_offset = 14
    _get_f_10_p7_method_offset = 15
    _set_f_10_p7_method_offset = 16
    _get_atmosphere_data_filename_method_offset = 17
    _set_atmosphere_data_filename_method_offset = 18
    _get_drag_model_type_method_offset = 19
    _set_drag_model_type_method_offset = 20
    _get_drag_model_plugin_name_method_offset = 21
    _set_drag_model_plugin_name_method_offset = 22
    _get_drag_model_plugin_method_offset = 23
    _get_variable_area_history_file_method_offset = 24
    _set_variable_area_history_file_method_offset = 25
    _get_n_plate_definition_file_method_offset = 26
    _set_n_plate_definition_file_method_offset = 27
    _metadata = {
        "iid_data" : (4778856633245712244, 14821126475863479963),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MarsGRAM2001)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_sun_position_metadata, value)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Path to namelist file."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @property
    def density_type(self) -> "MarsGRAMDensityType":
        """Low, mean, high or randomly perturbed density type."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"MarsGRAMDensityType") -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_density_type_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_f_10_p7_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MarsGRAM2001._metadata, MarsGRAM2001._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2001._metadata, MarsGRAM2001._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MarsGRAM2001."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MarsGRAM2001)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MarsGRAM2001, [MarsGRAM2001, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5061782166952998125, 12199095019979142569), MarsGRAM2001)
agcls.AgTypeNameMap["MarsGRAM2001"] = MarsGRAM2001

class MarsGRAM2005(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Mars-GRAM 2005 atmospheric model."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_data_directory_method_offset = 7
    _set_data_directory_method_offset = 8
    _get_namelist_file_method_offset = 9
    _set_namelist_file_method_offset = 10
    _get_density_type_method_offset = 11
    _set_density_type_method_offset = 12
    _get_atmosphere_data_source_method_offset = 13
    _set_atmosphere_data_source_method_offset = 14
    _get_f_10_p7_method_offset = 15
    _set_f_10_p7_method_offset = 16
    _get_atmosphere_data_filename_method_offset = 17
    _set_atmosphere_data_filename_method_offset = 18
    _get_drag_model_type_method_offset = 19
    _set_drag_model_type_method_offset = 20
    _get_drag_model_plugin_name_method_offset = 21
    _set_drag_model_plugin_name_method_offset = 22
    _get_drag_model_plugin_method_offset = 23
    _get_variable_area_history_file_method_offset = 24
    _set_variable_area_history_file_method_offset = 25
    _get_n_plate_definition_file_method_offset = 26
    _set_n_plate_definition_file_method_offset = 27
    _metadata = {
        "iid_data" : (4920835096822718445, 10487593085217522335),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MarsGRAM2005)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_sun_position_metadata, value)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Full path of namelist file."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @property
    def density_type(self) -> "MarsGRAMDensityType":
        """Low, mean, high or randomly perturbed density type."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"MarsGRAMDensityType") -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_density_type_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_f_10_p7_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MarsGRAM2005._metadata, MarsGRAM2005._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2005._metadata, MarsGRAM2005._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MarsGRAM2005."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MarsGRAM2005)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MarsGRAM2005, [MarsGRAM2005, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5209122239906139702, 12410207072342010548), MarsGRAM2005)
agcls.AgTypeNameMap["MarsGRAM2005"] = MarsGRAM2005

class MarsGRAM2010(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Mars-GRAM 2010 atmospheric model."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_data_directory_method_offset = 7
    _set_data_directory_method_offset = 8
    _get_namelist_file_method_offset = 9
    _set_namelist_file_method_offset = 10
    _get_density_type_method_offset = 11
    _set_density_type_method_offset = 12
    _get_atmosphere_data_source_method_offset = 13
    _set_atmosphere_data_source_method_offset = 14
    _get_f_10_p7_method_offset = 15
    _set_f_10_p7_method_offset = 16
    _get_atmosphere_data_filename_method_offset = 17
    _set_atmosphere_data_filename_method_offset = 18
    _get_drag_model_type_method_offset = 19
    _set_drag_model_type_method_offset = 20
    _get_drag_model_plugin_name_method_offset = 21
    _set_drag_model_plugin_name_method_offset = 22
    _get_drag_model_plugin_method_offset = 23
    _get_variable_area_history_file_method_offset = 24
    _set_variable_area_history_file_method_offset = 25
    _get_n_plate_definition_file_method_offset = 26
    _set_n_plate_definition_file_method_offset = 27
    _metadata = {
        "iid_data" : (5386740031750974041, 5758997999022083731),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MarsGRAM2010)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_sun_position_metadata, value)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Full path of namelist file."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @property
    def density_type(self) -> "MarsGRAMDensityType":
        """Low, mean, high or randomly perturbed density type."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MarsGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"MarsGRAMDensityType") -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_density_type_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_f_10_p7_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Get or set the atmospheric model data file path."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(MarsGRAM2010._metadata, MarsGRAM2010._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(MarsGRAM2010._metadata, MarsGRAM2010._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type MarsGRAM2010."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MarsGRAM2010)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, MarsGRAM2010, [MarsGRAM2010, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4909809469192368395, 8508181569633631878), MarsGRAM2010)
agcls.AgTypeNameMap["MarsGRAM2010"] = MarsGRAM2010

class VenusGRAM2005(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Venus-GRAM 2005 atmospheric model."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_data_directory_method_offset = 5
    _set_data_directory_method_offset = 6
    _get_namelist_file_method_offset = 7
    _set_namelist_file_method_offset = 8
    _get_density_type_method_offset = 9
    _set_density_type_method_offset = 10
    _get_drag_model_type_method_offset = 11
    _set_drag_model_type_method_offset = 12
    _get_drag_model_plugin_name_method_offset = 13
    _set_drag_model_plugin_name_method_offset = 14
    _get_drag_model_plugin_method_offset = 15
    _get_variable_area_history_file_method_offset = 16
    _set_variable_area_history_file_method_offset = 17
    _get_n_plate_definition_file_method_offset = 18
    _set_n_plate_definition_file_method_offset = 19
    _metadata = {
        "iid_data" : (5644980224795628572, 6106550432953708673),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, VenusGRAM2005)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_computes_pressure_metadata)

    _get_data_directory_metadata = { "offset" : _get_data_directory_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_directory(self) -> str:
        """Path to the data directory."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_data_directory_metadata)

    _set_data_directory_metadata = { "offset" : _set_data_directory_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_directory.setter
    def data_directory(self, value:str) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_data_directory_metadata, value)

    _get_namelist_file_metadata = { "offset" : _get_namelist_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def namelist_file(self) -> str:
        """Full path of namelist file."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_namelist_file_metadata)

    _set_namelist_file_metadata = { "offset" : _set_namelist_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @namelist_file.setter
    def namelist_file(self, value:str) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_namelist_file_metadata, value)

    _get_density_type_metadata = { "offset" : _get_density_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VenusGRAMDensityType),) }
    @property
    def density_type(self) -> "VenusGRAMDensityType":
        """Low, mean, high or randomly perturbed density type."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_density_type_metadata)

    _set_density_type_metadata = { "offset" : _set_density_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VenusGRAMDensityType),) }
    @density_type.setter
    def density_type(self, value:"VenusGRAMDensityType") -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_density_type_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_drag_model_plugin_metadata)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(VenusGRAM2005._metadata, VenusGRAM2005._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(VenusGRAM2005._metadata, VenusGRAM2005._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[data_directory] = "data_directory"
    _property_names[namelist_file] = "namelist_file"
    _property_names[density_type] = "density_type"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type VenusGRAM2005."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, VenusGRAM2005)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, VenusGRAM2005, [VenusGRAM2005, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4771553107029033260, 15501667541023956872), VenusGRAM2005)
agcls.AgTypeNameMap["VenusGRAM2005"] = VenusGRAM2005

class DTM2012(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the DTM 2012 atmospheric model."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_avg_method_offset = 9
    _set_f_10_p7_avg_method_offset = 10
    _get_atmosphere_data_filename_method_offset = 11
    _set_atmosphere_data_filename_method_offset = 12
    _get_drag_model_type_method_offset = 13
    _set_drag_model_type_method_offset = 14
    _get_drag_model_plugin_name_method_offset = 15
    _set_drag_model_plugin_name_method_offset = 16
    _get_drag_model_plugin_method_offset = 17
    _get_f_10_p7_method_offset = 18
    _set_f_10_p7_method_offset = 19
    _get_kp_method_offset = 20
    _set_kp_method_offset = 21
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 22
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 23
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 24
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (5360516758857901663, 16161184987610090152),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DTM2012)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_f_10_p7_avg_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Flux file."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_drag_model_plugin_metadata)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_f_10_p7_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate of geomagnetic flux values from the flux file."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(DTM2012._metadata, DTM2012._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(DTM2012._metadata, DTM2012._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type DTM2012."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DTM2012)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DTM2012, [DTM2012, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4618305370805059391, 6354340417883156401), DTM2012)
agcls.AgTypeNameMap["DTM2012"] = DTM2012

class DTM2020(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the DTM 2020 atmospheric model."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_approximate_altitude_method_offset = 1
    _set_use_approximate_altitude_method_offset = 2
    _get_computes_temperature_method_offset = 3
    _get_computes_pressure_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_atmosphere_data_source_method_offset = 7
    _set_atmosphere_data_source_method_offset = 8
    _get_f_10_p7_avg_method_offset = 9
    _set_f_10_p7_avg_method_offset = 10
    _get_atmosphere_data_filename_method_offset = 11
    _set_atmosphere_data_filename_method_offset = 12
    _get_drag_model_type_method_offset = 13
    _set_drag_model_type_method_offset = 14
    _get_drag_model_plugin_name_method_offset = 15
    _set_drag_model_plugin_name_method_offset = 16
    _get_drag_model_plugin_method_offset = 17
    _get_f_10_p7_method_offset = 18
    _set_f_10_p7_method_offset = 19
    _get_kp_method_offset = 20
    _set_kp_method_offset = 21
    _get_atmosphere_data_geo_magnetic_flux_source_method_offset = 22
    _set_atmosphere_data_geo_magnetic_flux_source_method_offset = 23
    _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 24
    _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset = 25
    _get_variable_area_history_file_method_offset = 26
    _set_variable_area_history_file_method_offset = 27
    _get_n_plate_definition_file_method_offset = 28
    _set_n_plate_definition_file_method_offset = 29
    _metadata = {
        "iid_data" : (4714451895545662258, 8426786274041618100),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DTM2020)

    _get_use_approximate_altitude_metadata = { "offset" : _get_use_approximate_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approximate_altitude(self) -> bool:
        """True if using approximate altitude formula."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_use_approximate_altitude_metadata)

    _set_use_approximate_altitude_metadata = { "offset" : _set_use_approximate_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approximate_altitude.setter
    def use_approximate_altitude(self, value:bool) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_use_approximate_altitude_metadata, value)

    _get_computes_temperature_metadata = { "offset" : _get_computes_temperature_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_temperature(self) -> bool:
        """Flag indicates whether this model computes temperature."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_computes_temperature_metadata)

    _get_computes_pressure_metadata = { "offset" : _get_computes_pressure_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def computes_pressure(self) -> bool:
        """Flag indicates whether this model computes pressure."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_computes_pressure_metadata)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_sun_position_metadata, value)

    _get_atmosphere_data_source_metadata = { "offset" : _get_atmosphere_data_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @property
    def atmosphere_data_source(self) -> "AtmosphereDataSource":
        """Get or set the atmospheric model data source - data file or constant values."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_atmosphere_data_source_metadata)

    _set_atmosphere_data_source_metadata = { "offset" : _set_atmosphere_data_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereDataSource),) }
    @atmosphere_data_source.setter
    def atmosphere_data_source(self, value:"AtmosphereDataSource") -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_atmosphere_data_source_metadata, value)

    _get_f_10_p7_avg_metadata = { "offset" : _get_f_10_p7_avg_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7_avg(self) -> float:
        """Average solar Flux (F10.7); the 81-day averaged Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_f_10_p7_avg_metadata)

    _set_f_10_p7_avg_metadata = { "offset" : _set_f_10_p7_avg_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7_avg.setter
    def f_10_p7_avg(self, value:float) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_f_10_p7_avg_metadata, value)

    _get_atmosphere_data_filename_metadata = { "offset" : _get_atmosphere_data_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_data_filename(self) -> str:
        """Flux file."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_atmosphere_data_filename_metadata)

    _set_atmosphere_data_filename_metadata = { "offset" : _set_atmosphere_data_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_data_filename.setter
    def atmosphere_data_filename(self, value:str) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_atmosphere_data_filename_metadata, value)

    _get_drag_model_type_metadata = { "offset" : _get_drag_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @property
    def drag_model_type(self) -> "DragModelType":
        """Drag model type."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_drag_model_type_metadata)

    _set_drag_model_type_metadata = { "offset" : _set_drag_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DragModelType),) }
    @drag_model_type.setter
    def drag_model_type(self, value:"DragModelType") -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_drag_model_type_metadata, value)

    _get_drag_model_plugin_name_metadata = { "offset" : _get_drag_model_plugin_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def drag_model_plugin_name(self) -> str:
        """Get or set the name of the drag model plugin."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_drag_model_plugin_name_metadata)

    _set_drag_model_plugin_name_metadata = { "offset" : _set_drag_model_plugin_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @drag_model_plugin_name.setter
    def drag_model_plugin_name(self, value:str) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_drag_model_plugin_name_metadata, value)

    _get_drag_model_plugin_metadata = { "offset" : _get_drag_model_plugin_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def drag_model_plugin(self) -> "DragModelPlugin":
        """Drag model plugin properties."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_drag_model_plugin_metadata)

    _get_f_10_p7_metadata = { "offset" : _get_f_10_p7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def f_10_p7(self) -> float:
        """Solar Flux (F10.7); the daily Ottawa 10.7 cm solar flux value. Dimensionless."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_f_10_p7_metadata)

    _set_f_10_p7_metadata = { "offset" : _set_f_10_p7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @f_10_p7.setter
    def f_10_p7(self, value:float) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_f_10_p7_metadata, value)

    _get_kp_metadata = { "offset" : _get_kp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def kp(self) -> float:
        """Geomagnetic Index (Kp). Dimensionless."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_kp_metadata)

    _set_kp_metadata = { "offset" : _set_kp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @kp.setter
    def kp(self, value:float) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_kp_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @property
    def atmosphere_data_geo_magnetic_flux_source(self) -> "GeoMagneticFluxSource":
        """Whether to use Kp or Ap data from the flux file."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_atmosphere_data_geo_magnetic_flux_source_metadata)

    _set_atmosphere_data_geo_magnetic_flux_source_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxSource),) }
    @atmosphere_data_geo_magnetic_flux_source.setter
    def atmosphere_data_geo_magnetic_flux_source(self, value:"GeoMagneticFluxSource") -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_atmosphere_data_geo_magnetic_flux_source_metadata, value)

    _get_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _get_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @property
    def atmosphere_data_geo_magnetic_flux_update_rate(self) -> "GeoMagneticFluxUpdateRate":
        """Get or set the update rate of geomagnetic flux values from the flux file."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_atmosphere_data_geo_magnetic_flux_update_rate_metadata)

    _set_atmosphere_data_geo_magnetic_flux_update_rate_metadata = { "offset" : _set_atmosphere_data_geo_magnetic_flux_update_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GeoMagneticFluxUpdateRate),) }
    @atmosphere_data_geo_magnetic_flux_update_rate.setter
    def atmosphere_data_geo_magnetic_flux_update_rate(self, value:"GeoMagneticFluxUpdateRate") -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_atmosphere_data_geo_magnetic_flux_update_rate_metadata, value)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Drag variable area history file."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_variable_area_history_file_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Drag N-Plate definition file."""
        return self._intf.get_property(DTM2020._metadata, DTM2020._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(DTM2020._metadata, DTM2020._set_n_plate_definition_file_metadata, value)

    _property_names[use_approximate_altitude] = "use_approximate_altitude"
    _property_names[computes_temperature] = "computes_temperature"
    _property_names[computes_pressure] = "computes_pressure"
    _property_names[sun_position] = "sun_position"
    _property_names[atmosphere_data_source] = "atmosphere_data_source"
    _property_names[f_10_p7_avg] = "f_10_p7_avg"
    _property_names[atmosphere_data_filename] = "atmosphere_data_filename"
    _property_names[drag_model_type] = "drag_model_type"
    _property_names[drag_model_plugin_name] = "drag_model_plugin_name"
    _property_names[drag_model_plugin] = "drag_model_plugin"
    _property_names[f_10_p7] = "f_10_p7"
    _property_names[kp] = "kp"
    _property_names[atmosphere_data_geo_magnetic_flux_source] = "atmosphere_data_geo_magnetic_flux_source"
    _property_names[atmosphere_data_geo_magnetic_flux_update_rate] = "atmosphere_data_geo_magnetic_flux_update_rate"
    _property_names[variable_area_history_file] = "variable_area_history_file"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type DTM2020."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DTM2020)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DTM2020, [DTM2020, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5608141479643281526, 8933387321817404818), DTM2020)
agcls.AgTypeNameMap["DTM2020"] = DTM2020

class GravityFieldFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Gravitational Force gravity model - a complex gravitational force calculation, optionally including solid and ocean tide effects."""

    _num_methods = 35
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_gravity_filename_method_offset = 1
    _set_gravity_filename_method_offset = 2
    _get_degree_method_offset = 3
    _set_degree_method_offset = 4
    _get_order_method_offset = 5
    _set_order_method_offset = 6
    _get_max_degree_text_method_offset = 7
    _get_max_order_text_method_offset = 8
    _get_include_time_dependent_solid_tides_method_offset = 9
    _set_include_time_dependent_solid_tides_method_offset = 10
    _get_solid_tide_min_amp_method_offset = 11
    _set_solid_tide_min_amp_method_offset = 12
    _get_use_ocean_tides_method_offset = 13
    _set_use_ocean_tides_method_offset = 14
    _get_ocean_tide_min_amplitude_method_offset = 15
    _set_ocean_tide_min_amplitude_method_offset = 16
    _get_min_radius_percent_method_offset = 17
    _set_min_radius_percent_method_offset = 18
    _get_central_body_name_method_offset = 19
    _get_ocean_tide_max_degree_method_offset = 20
    _set_ocean_tide_max_degree_method_offset = 21
    _get_ocean_tide_max_order_method_offset = 22
    _set_ocean_tide_max_order_method_offset = 23
    _get_solid_tide_type_method_offset = 24
    _set_solid_tide_type_method_offset = 25
    _get_truncate_solid_tides_method_offset = 26
    _set_truncate_solid_tides_method_offset = 27
    _get_use_secular_variations_method_offset = 28
    _set_use_secular_variations_method_offset = 29
    _get_partials_degree_method_offset = 30
    _set_partials_degree_method_offset = 31
    _get_partials_order_method_offset = 32
    _set_partials_order_method_offset = 33
    _get_max_partials_degree_text_method_offset = 34
    _get_max_partials_order_text_method_offset = 35
    _metadata = {
        "iid_data" : (5524396550678766518, 16059984052708385960),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GravityFieldFunction)

    _get_gravity_filename_metadata = { "offset" : _get_gravity_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def gravity_filename(self) -> str:
        """Get or set the name of the file containing the gravity field."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_gravity_filename_metadata)

    _set_gravity_filename_metadata = { "offset" : _set_gravity_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @gravity_filename.setter
    def gravity_filename(self, value:str) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_gravity_filename_metadata, value)

    _get_degree_metadata = { "offset" : _get_degree_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def degree(self) -> int:
        """Get or set the degree of geopotential coefficients to be included for Central Body gravity computations. Valid range is from 0 to 90, depending on the gravity model. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_degree_metadata)

    _set_degree_metadata = { "offset" : _set_degree_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @degree.setter
    def degree(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_degree_metadata, value)

    _get_order_metadata = { "offset" : _get_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def order(self) -> int:
        """Get or set the order of geopotential coefficients to be included for Central Body gravity computations. Valid range is from 0 to 90, depending on the gravity model. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_order_metadata)

    _set_order_metadata = { "offset" : _set_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @order.setter
    def order(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_order_metadata, value)

    _get_max_degree_text_metadata = { "offset" : _get_max_degree_text_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def max_degree_text(self) -> str:
        """Displays the maximum degree permissible for the gravity model."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_max_degree_text_metadata)

    _get_max_order_text_metadata = { "offset" : _get_max_order_text_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def max_order_text(self) -> str:
        """Displays the maximum order permissible for the gravity model."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_max_order_text_metadata)

    _get_include_time_dependent_solid_tides_metadata = { "offset" : _get_include_time_dependent_solid_tides_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_time_dependent_solid_tides(self) -> bool:
        """True if including time dependent solid tides."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_include_time_dependent_solid_tides_metadata)

    _set_include_time_dependent_solid_tides_metadata = { "offset" : _set_include_time_dependent_solid_tides_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_time_dependent_solid_tides.setter
    def include_time_dependent_solid_tides(self, value:bool) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_include_time_dependent_solid_tides_metadata, value)

    _get_solid_tide_min_amp_metadata = { "offset" : _get_solid_tide_min_amp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solid_tide_min_amp(self) -> float:
        """Get or set the minimum amplitude for solid tides; contributors that are below the minimum amplitude will not be factored into the computation. Uses SmallDistance Dimension."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_solid_tide_min_amp_metadata)

    _set_solid_tide_min_amp_metadata = { "offset" : _set_solid_tide_min_amp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solid_tide_min_amp.setter
    def solid_tide_min_amp(self, value:float) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_solid_tide_min_amp_metadata, value)

    _get_use_ocean_tides_metadata = { "offset" : _get_use_ocean_tides_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_ocean_tides(self) -> bool:
        """True if using ocean tides."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_use_ocean_tides_metadata)

    _set_use_ocean_tides_metadata = { "offset" : _set_use_ocean_tides_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_ocean_tides.setter
    def use_ocean_tides(self, value:bool) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_use_ocean_tides_metadata, value)

    _get_ocean_tide_min_amplitude_metadata = { "offset" : _get_ocean_tide_min_amplitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ocean_tide_min_amplitude(self) -> float:
        """Get or set the minimum amplitude for ocean tides; contributors that are below the minimum amplitude will not be factored into the computation. Uses SmallDistance Dimension."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_ocean_tide_min_amplitude_metadata)

    _set_ocean_tide_min_amplitude_metadata = { "offset" : _set_ocean_tide_min_amplitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @ocean_tide_min_amplitude.setter
    def ocean_tide_min_amplitude(self, value:float) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_ocean_tide_min_amplitude_metadata, value)

    _get_min_radius_percent_metadata = { "offset" : _get_min_radius_percent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_radius_percent(self) -> float:
        """Get or set the percentage of the central body's minimum radius at which a modified force model (only the two-body force) will be used - provided there is no altitude stopping condition. Uses Percent Dimension."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_min_radius_percent_metadata)

    _set_min_radius_percent_metadata = { "offset" : _set_min_radius_percent_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_radius_percent.setter
    def min_radius_percent(self, value:float) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_min_radius_percent_metadata, value)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get the name of the central body."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_central_body_name_metadata)

    _get_ocean_tide_max_degree_metadata = { "offset" : _get_ocean_tide_max_degree_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def ocean_tide_max_degree(self) -> int:
        """Get or set the maximum degree for force contributions from ocean tides that will be included in the computation. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_ocean_tide_max_degree_metadata)

    _set_ocean_tide_max_degree_metadata = { "offset" : _set_ocean_tide_max_degree_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @ocean_tide_max_degree.setter
    def ocean_tide_max_degree(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_ocean_tide_max_degree_metadata, value)

    _get_ocean_tide_max_order_metadata = { "offset" : _get_ocean_tide_max_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def ocean_tide_max_order(self) -> int:
        """Get or set the maximum order for force contributions from ocean tides that will be included in the computation. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_ocean_tide_max_order_metadata)

    _set_ocean_tide_max_order_metadata = { "offset" : _set_ocean_tide_max_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @ocean_tide_max_order.setter
    def ocean_tide_max_order(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_ocean_tide_max_order_metadata, value)

    _get_solid_tide_type_metadata = { "offset" : _get_solid_tide_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SolidTide),) }
    @property
    def solid_tide_type(self) -> "SolidTide":
        """Get or set the type of solid tide contribution to be modeled."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_solid_tide_type_metadata)

    _set_solid_tide_type_metadata = { "offset" : _set_solid_tide_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SolidTide),) }
    @solid_tide_type.setter
    def solid_tide_type(self, solid_tide:"SolidTide") -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_solid_tide_type_metadata, solid_tide)

    _get_truncate_solid_tides_metadata = { "offset" : _get_truncate_solid_tides_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def truncate_solid_tides(self) -> bool:
        """True if solid tide terms (including permanent tide) won't be included beyond the degree and order selected for the gravity model."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_truncate_solid_tides_metadata)

    _set_truncate_solid_tides_metadata = { "offset" : _set_truncate_solid_tides_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @truncate_solid_tides.setter
    def truncate_solid_tides(self, value:bool) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_truncate_solid_tides_metadata, value)

    _get_use_secular_variations_metadata = { "offset" : _get_use_secular_variations_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_secular_variations(self) -> bool:
        """Opt whether to include or ignore secular variations defined by the gravity field model."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_use_secular_variations_metadata)

    _set_use_secular_variations_metadata = { "offset" : _set_use_secular_variations_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_secular_variations.setter
    def use_secular_variations(self, value:bool) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_use_secular_variations_metadata, value)

    _get_partials_degree_metadata = { "offset" : _get_partials_degree_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def partials_degree(self) -> int:
        """Get or set the degree of geopotential coefficients to be included for Central Body gravity state transition matrix computations. Valid range is from 0 to 90, depending on the gravity model and the degree used for state computations. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_partials_degree_metadata)

    _set_partials_degree_metadata = { "offset" : _set_partials_degree_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @partials_degree.setter
    def partials_degree(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_partials_degree_metadata, value)

    _get_partials_order_metadata = { "offset" : _get_partials_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def partials_order(self) -> int:
        """Get or set the order of geopotential coefficients to be included for Central Body gravity state transition matrix computations. Valid range is from 0 to 90, depending on the gravity model and the order used for state computations. Dimensionless."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_partials_order_metadata)

    _set_partials_order_metadata = { "offset" : _set_partials_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @partials_order.setter
    def partials_order(self, value:int) -> None:
        return self._intf.set_property(GravityFieldFunction._metadata, GravityFieldFunction._set_partials_order_metadata, value)

    _get_max_partials_degree_text_metadata = { "offset" : _get_max_partials_degree_text_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def max_partials_degree_text(self) -> str:
        """Displays the maximum degree permissible for the gravity model partials used in the STM."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_max_partials_degree_text_metadata)

    _get_max_partials_order_text_metadata = { "offset" : _get_max_partials_order_text_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def max_partials_order_text(self) -> str:
        """Displays the maximum order permissible for the gravity model partials used in the STM."""
        return self._intf.get_property(GravityFieldFunction._metadata, GravityFieldFunction._get_max_partials_order_text_metadata)

    _property_names[gravity_filename] = "gravity_filename"
    _property_names[degree] = "degree"
    _property_names[order] = "order"
    _property_names[max_degree_text] = "max_degree_text"
    _property_names[max_order_text] = "max_order_text"
    _property_names[include_time_dependent_solid_tides] = "include_time_dependent_solid_tides"
    _property_names[solid_tide_min_amp] = "solid_tide_min_amp"
    _property_names[use_ocean_tides] = "use_ocean_tides"
    _property_names[ocean_tide_min_amplitude] = "ocean_tide_min_amplitude"
    _property_names[min_radius_percent] = "min_radius_percent"
    _property_names[central_body_name] = "central_body_name"
    _property_names[ocean_tide_max_degree] = "ocean_tide_max_degree"
    _property_names[ocean_tide_max_order] = "ocean_tide_max_order"
    _property_names[solid_tide_type] = "solid_tide_type"
    _property_names[truncate_solid_tides] = "truncate_solid_tides"
    _property_names[use_secular_variations] = "use_secular_variations"
    _property_names[partials_degree] = "partials_degree"
    _property_names[partials_order] = "partials_order"
    _property_names[max_partials_degree_text] = "max_partials_degree_text"
    _property_names[max_partials_order_text] = "max_partials_order_text"

    def __init__(self, source_object=None):
        """Construct an object of type GravityFieldFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GravityFieldFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GravityFieldFunction, [GravityFieldFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5465429656469651541, 11427577276297574311), GravityFieldFunction)
agcls.AgTypeNameMap["GravityFieldFunction"] = GravityFieldFunction

class PointMassFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Point Mass Function."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_gravitational_parameter_source_method_offset = 1
    _set_gravitational_parameter_source_method_offset = 2
    _get_mu_method_offset = 3
    _set_mu_method_offset = 4
    _metadata = {
        "iid_data" : (5462605398119434458, 11783998325358715305),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PointMassFunction)

    _get_gravitational_parameter_source_metadata = { "offset" : _get_gravitational_parameter_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GravParamSource),) }
    @property
    def gravitational_parameter_source(self) -> "GravParamSource":
        """Get or set the source for the third body's gravitational parameter."""
        return self._intf.get_property(PointMassFunction._metadata, PointMassFunction._get_gravitational_parameter_source_metadata)

    _set_gravitational_parameter_source_metadata = { "offset" : _set_gravitational_parameter_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GravParamSource),) }
    @gravitational_parameter_source.setter
    def gravitational_parameter_source(self, value:"GravParamSource") -> None:
        return self._intf.set_property(PointMassFunction._metadata, PointMassFunction._set_gravitational_parameter_source_metadata, value)

    _get_mu_metadata = { "offset" : _get_mu_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mu(self) -> float:
        """Get or set the gravitational parameter. Uses Gravity Param Dimension."""
        return self._intf.get_property(PointMassFunction._metadata, PointMassFunction._get_mu_metadata)

    _set_mu_metadata = { "offset" : _set_mu_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mu.setter
    def mu(self, value:float) -> None:
        return self._intf.set_property(PointMassFunction._metadata, PointMassFunction._set_mu_metadata, value)

    _property_names[gravitational_parameter_source] = "gravitational_parameter_source"
    _property_names[mu] = "mu"

    def __init__(self, source_object=None):
        """Construct an object of type PointMassFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PointMassFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PointMassFunction, [PointMassFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4889616998052485421, 3064578209889532067), PointMassFunction)
agcls.AgTypeNameMap["PointMassFunction"] = PointMassFunction

class TwoBodyFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Two Body gravity model - a standard point mass model."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_gravitational_parameter_source_method_offset = 1
    _set_gravitational_parameter_source_method_offset = 2
    _get_mu_method_offset = 3
    _set_mu_method_offset = 4
    _get_min_radius_percent_method_offset = 5
    _set_min_radius_percent_method_offset = 6
    _metadata = {
        "iid_data" : (4706705304387777866, 7919127694329746305),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TwoBodyFunction)

    _get_gravitational_parameter_source_metadata = { "offset" : _get_gravitational_parameter_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GravParamSource),) }
    @property
    def gravitational_parameter_source(self) -> "GravParamSource":
        """Get or set the source for the gravitational parameter."""
        return self._intf.get_property(TwoBodyFunction._metadata, TwoBodyFunction._get_gravitational_parameter_source_metadata)

    _set_gravitational_parameter_source_metadata = { "offset" : _set_gravitational_parameter_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GravParamSource),) }
    @gravitational_parameter_source.setter
    def gravitational_parameter_source(self, value:"GravParamSource") -> None:
        return self._intf.set_property(TwoBodyFunction._metadata, TwoBodyFunction._set_gravitational_parameter_source_metadata, value)

    _get_mu_metadata = { "offset" : _get_mu_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mu(self) -> float:
        """Get or set the gravitational parameter. Uses Gravity Param Dimension."""
        return self._intf.get_property(TwoBodyFunction._metadata, TwoBodyFunction._get_mu_metadata)

    _set_mu_metadata = { "offset" : _set_mu_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mu.setter
    def mu(self, value:float) -> None:
        return self._intf.set_property(TwoBodyFunction._metadata, TwoBodyFunction._set_mu_metadata, value)

    _get_min_radius_percent_metadata = { "offset" : _get_min_radius_percent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_radius_percent(self) -> float:
        """Get or set the percentage of the central body's minimum radius at which a modified force model (only the two-body force) will be used - provided there is no altitude stopping condition. Uses Percent Dimension."""
        return self._intf.get_property(TwoBodyFunction._metadata, TwoBodyFunction._get_min_radius_percent_metadata)

    _set_min_radius_percent_metadata = { "offset" : _set_min_radius_percent_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_radius_percent.setter
    def min_radius_percent(self, value:float) -> None:
        return self._intf.set_property(TwoBodyFunction._metadata, TwoBodyFunction._set_min_radius_percent_metadata, value)

    _property_names[gravitational_parameter_source] = "gravitational_parameter_source"
    _property_names[mu] = "mu"
    _property_names[min_radius_percent] = "min_radius_percent"

    def __init__(self, source_object=None):
        """Construct an object of type TwoBodyFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TwoBodyFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, TwoBodyFunction, [TwoBodyFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5589893013807683778, 10547061623759300008), TwoBodyFunction)
agcls.AgTypeNameMap["TwoBodyFunction"] = TwoBodyFunction

class HPOPPluginFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the HPOP Plugin propagator function."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_plugin_identifier_method_offset = 1
    _set_plugin_identifier_method_offset = 2
    _get_plugin_config_method_offset = 3
    _metadata = {
        "iid_data" : (4969864186118360684, 16828364214523179952),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, HPOPPluginFunction)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the plugin name."""
        return self._intf.get_property(HPOPPluginFunction._metadata, HPOPPluginFunction._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(HPOPPluginFunction._metadata, HPOPPluginFunction._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(HPOPPluginFunction._metadata, HPOPPluginFunction._get_plugin_config_metadata)

    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"

    def __init__(self, source_object=None):
        """Construct an object of type HPOPPluginFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, HPOPPluginFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, HPOPPluginFunction, [HPOPPluginFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5310367860533452450, 396895054879317942), HPOPPluginFunction)
agcls.AgTypeNameMap["HPOPPluginFunction"] = HPOPPluginFunction

class EOMFuncPluginFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the EOM Function Plugin propagator function."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_plugin_identifier_method_offset = 1
    _set_plugin_identifier_method_offset = 2
    _get_plugin_config_method_offset = 3
    _metadata = {
        "iid_data" : (5400616710515627677, 9364901696839076241),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EOMFuncPluginFunction)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the plugin name."""
        return self._intf.get_property(EOMFuncPluginFunction._metadata, EOMFuncPluginFunction._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(EOMFuncPluginFunction._metadata, EOMFuncPluginFunction._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(EOMFuncPluginFunction._metadata, EOMFuncPluginFunction._get_plugin_config_metadata)

    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"

    def __init__(self, source_object=None):
        """Construct an object of type EOMFuncPluginFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EOMFuncPluginFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EOMFuncPluginFunction, [EOMFuncPluginFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5223247057825617700, 18398972489609883042), EOMFuncPluginFunction)
agcls.AgTypeNameMap["EOMFuncPluginFunction"] = EOMFuncPluginFunction

class SRPAerospaceT20(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Aerospace T20 solar radiation pressure model for GPS block IIA."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (4923355036596117844, 13873513725574284471),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPAerospaceT20)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPAerospaceT20._metadata, SRPAerospaceT20._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPAerospaceT20._metadata, SRPAerospaceT20._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPAerospaceT20."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPAerospaceT20)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPAerospaceT20, [SRPAerospaceT20, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5040644487386490720, 8016746528186754470), SRPAerospaceT20)
agcls.AgTypeNameMap["SRPAerospaceT20"] = SRPAerospaceT20

class SRPAerospaceT30(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Aerospace T30 solar radiation pressure model for GPS block IIR."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (5070077088478642131, 13573356320157914276),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPAerospaceT30)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPAerospaceT30._metadata, SRPAerospaceT30._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPAerospaceT30._metadata, SRPAerospaceT30._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPAerospaceT30."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPAerospaceT30)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPAerospaceT30, [SRPAerospaceT30, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5064742270983407105, 17229057075486729390), SRPAerospaceT30)
agcls.AgTypeNameMap["SRPAerospaceT30"] = SRPAerospaceT30

class SRPGSPM04aIIA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Bar-Sever GPS Solar Pressure Model 04a for block IIA."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (4682363418069451558, 11356800664389510820),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPGSPM04aIIA)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aIIA._metadata, SRPGSPM04aIIA._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPGSPM04aIIA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPGSPM04aIIA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPGSPM04aIIA, [SRPGSPM04aIIA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5065459968903642120, 15868220137074428593), SRPGSPM04aIIA)
agcls.AgTypeNameMap["SRPGSPM04aIIA"] = SRPGSPM04aIIA

class SRPGSPM04aIIR(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Bar-Sever GPS Solar Pressure Model 04a for block IIR."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (5755208208197003276, 5041409373774569878),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPGSPM04aIIR)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aIIR._metadata, SRPGSPM04aIIR._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPGSPM04aIIR."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPGSPM04aIIR)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPGSPM04aIIR, [SRPGSPM04aIIR, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5159592724339510192, 6236067790114421397), SRPGSPM04aIIR)
agcls.AgTypeNameMap["SRPGSPM04aIIR"] = SRPGSPM04aIIR

class SRPGSPM04aeIIA(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Bar-Sever GPS Solar Pressure Model 04ae for block IIA."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (4679833496780922683, 8986734930070695298),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPGSPM04aeIIA)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aeIIA._metadata, SRPGSPM04aeIIA._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPGSPM04aeIIA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPGSPM04aeIIA)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPGSPM04aeIIA, [SRPGSPM04aeIIA, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4704207188197051273, 14854464675918841478), SRPGSPM04aeIIA)
agcls.AgTypeNameMap["SRPGSPM04aeIIA"] = SRPGSPM04aeIIA

class SRPGSPM04aeIIR(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Bar-Sever GPS Solar Pressure Model 04ae for block IIR."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_include_boundary_mitigation_method_offset = 8
    _set_include_boundary_mitigation_method_offset = 9
    _get_use_sun_central_body_file_values_method_offset = 10
    _set_use_sun_central_body_file_values_method_offset = 11
    _get_solar_radius_method_offset = 12
    _set_solar_radius_method_offset = 13
    _metadata = {
        "iid_data" : (4901489248279768889, 2643223923493711252),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPGSPM04aeIIR)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar radius should come from the Sun.cb file."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPGSPM04aeIIR._metadata, SRPGSPM04aeIIR._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPGSPM04aeIIR."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPGSPM04aeIIR)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPGSPM04aeIIR, [SRPGSPM04aeIIR, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4990438641832144132, 5202502645857195413), SRPGSPM04aeIIR)
agcls.AgTypeNameMap["SRPGSPM04aeIIR"] = SRPGSPM04aeIIR

class SRPSpherical(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Spherical SRP model; assumes a spherical spacecraft. The equation used by STK is described in the Solar Radiation technical note."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_mean_flux_method_offset = 8
    _set_mean_flux_method_offset = 9
    _get_luminosity_method_offset = 10
    _set_luminosity_method_offset = 11
    _get_solar_force_method_method_offset = 12
    _set_solar_force_method_method_offset = 13
    _get_include_boundary_mitigation_method_offset = 14
    _set_include_boundary_mitigation_method_offset = 15
    _get_use_sun_central_body_file_values_method_offset = 16
    _set_use_sun_central_body_file_values_method_offset = 17
    _get_solar_radius_method_offset = 18
    _set_solar_radius_method_offset = 19
    _metadata = {
        "iid_data" : (4935688664894662660, 12720226864849181351),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPSpherical)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_eclipsing_bodies_metadata)

    _get_mean_flux_metadata = { "offset" : _get_mean_flux_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_flux(self) -> float:
        """Get or set the mean solar flux at 1 au (W/m^2)."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_mean_flux_metadata)

    _set_mean_flux_metadata = { "offset" : _set_mean_flux_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_flux.setter
    def mean_flux(self, value:float) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_mean_flux_metadata, value)

    _get_luminosity_metadata = { "offset" : _get_luminosity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def luminosity(self) -> float:
        """Get or set the luminosity of sun. Dimensionless."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_luminosity_metadata)

    _set_luminosity_metadata = { "offset" : _set_luminosity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @luminosity.setter
    def luminosity(self, value:float) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_luminosity_metadata, value)

    _get_solar_force_method_metadata = { "offset" : _get_solar_force_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @property
    def solar_force_method(self) -> "SolarForceMethod":
        """Get or set the solar force method."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_solar_force_method_metadata)

    _set_solar_force_method_metadata = { "offset" : _set_solar_force_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @solar_force_method.setter
    def solar_force_method(self, value:"SolarForceMethod") -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_solar_force_method_metadata, value)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar values should come from the Sun.cb file."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPSpherical._metadata, SRPSpherical._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPSpherical._metadata, SRPSpherical._set_solar_radius_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[mean_flux] = "mean_flux"
    _property_names[luminosity] = "luminosity"
    _property_names[solar_force_method] = "solar_force_method"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPSpherical."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPSpherical)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPSpherical, [SRPSpherical, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5125877137703219255, 8400477721897989536), SRPSpherical)
agcls.AgTypeNameMap["SRPSpherical"] = SRPSpherical

class SRPNPlate(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the N-plate SRP model."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_mean_flux_method_offset = 8
    _set_mean_flux_method_offset = 9
    _get_luminosity_method_offset = 10
    _set_luminosity_method_offset = 11
    _get_solar_force_method_method_offset = 12
    _set_solar_force_method_method_offset = 13
    _get_include_boundary_mitigation_method_offset = 14
    _set_include_boundary_mitigation_method_offset = 15
    _get_use_sun_central_body_file_values_method_offset = 16
    _set_use_sun_central_body_file_values_method_offset = 17
    _get_solar_radius_method_offset = 18
    _set_solar_radius_method_offset = 19
    _get_n_plate_definition_file_method_offset = 20
    _set_n_plate_definition_file_method_offset = 21
    _metadata = {
        "iid_data" : (5014342700106255399, 15101597874313585044),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPNPlate)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_eclipsing_bodies_metadata)

    _get_mean_flux_metadata = { "offset" : _get_mean_flux_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_flux(self) -> float:
        """Get or set the mean solar flux at 1 au (W/m^2)."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_mean_flux_metadata)

    _set_mean_flux_metadata = { "offset" : _set_mean_flux_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_flux.setter
    def mean_flux(self, value:float) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_mean_flux_metadata, value)

    _get_luminosity_metadata = { "offset" : _get_luminosity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def luminosity(self) -> float:
        """Get or set the luminosity of sun. Dimensionless."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_luminosity_metadata)

    _set_luminosity_metadata = { "offset" : _set_luminosity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @luminosity.setter
    def luminosity(self, value:float) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_luminosity_metadata, value)

    _get_solar_force_method_metadata = { "offset" : _get_solar_force_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @property
    def solar_force_method(self) -> "SolarForceMethod":
        """Get or set the solar force method."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_solar_force_method_metadata)

    _set_solar_force_method_metadata = { "offset" : _set_solar_force_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @solar_force_method.setter
    def solar_force_method(self, value:"SolarForceMethod") -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_solar_force_method_metadata, value)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar values should come from the Sun.cb file."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_solar_radius_metadata, value)

    _get_n_plate_definition_file_metadata = { "offset" : _get_n_plate_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def n_plate_definition_file(self) -> str:
        """Full path of NPlate definition file."""
        return self._intf.get_property(SRPNPlate._metadata, SRPNPlate._get_n_plate_definition_file_metadata)

    _set_n_plate_definition_file_metadata = { "offset" : _set_n_plate_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @n_plate_definition_file.setter
    def n_plate_definition_file(self, value:str) -> None:
        return self._intf.set_property(SRPNPlate._metadata, SRPNPlate._set_n_plate_definition_file_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[mean_flux] = "mean_flux"
    _property_names[luminosity] = "luminosity"
    _property_names[solar_force_method] = "solar_force_method"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"
    _property_names[n_plate_definition_file] = "n_plate_definition_file"

    def __init__(self, source_object=None):
        """Construct an object of type SRPNPlate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPNPlate)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPNPlate, [SRPNPlate, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4645210293341138373, 9981460367221995948), SRPNPlate)
agcls.AgTypeNameMap["SRPNPlate"] = SRPNPlate

class SRPTabulatedAreaVector(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the tabulated area vector SRP model."""

    _num_methods = 23
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_mean_flux_method_offset = 8
    _set_mean_flux_method_offset = 9
    _get_luminosity_method_offset = 10
    _set_luminosity_method_offset = 11
    _get_solar_force_method_method_offset = 12
    _set_solar_force_method_method_offset = 13
    _get_include_boundary_mitigation_method_offset = 14
    _set_include_boundary_mitigation_method_offset = 15
    _get_use_sun_central_body_file_values_method_offset = 16
    _set_use_sun_central_body_file_values_method_offset = 17
    _get_solar_radius_method_offset = 18
    _set_solar_radius_method_offset = 19
    _get_tab_area_vector_definition_file_method_offset = 20
    _set_tab_area_vector_definition_file_method_offset = 21
    _get_interpolation_method_method_offset = 22
    _set_interpolation_method_method_offset = 23
    _metadata = {
        "iid_data" : (4833860589877898808, 18366789859238573226),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPTabulatedAreaVector)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_eclipsing_bodies_metadata)

    _get_mean_flux_metadata = { "offset" : _get_mean_flux_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_flux(self) -> float:
        """Get or set the mean solar flux at 1 au (W/m^2)."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_mean_flux_metadata)

    _set_mean_flux_metadata = { "offset" : _set_mean_flux_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_flux.setter
    def mean_flux(self, value:float) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_mean_flux_metadata, value)

    _get_luminosity_metadata = { "offset" : _get_luminosity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def luminosity(self) -> float:
        """Get or set the luminosity of sun. Dimensionless."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_luminosity_metadata)

    _set_luminosity_metadata = { "offset" : _set_luminosity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @luminosity.setter
    def luminosity(self, value:float) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_luminosity_metadata, value)

    _get_solar_force_method_metadata = { "offset" : _get_solar_force_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @property
    def solar_force_method(self) -> "SolarForceMethod":
        """Get or set the solar force method."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_solar_force_method_metadata)

    _set_solar_force_method_metadata = { "offset" : _set_solar_force_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @solar_force_method.setter
    def solar_force_method(self, value:"SolarForceMethod") -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_solar_force_method_metadata, value)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar values should come from the Sun.cb file."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_solar_radius_metadata, value)

    _get_tab_area_vector_definition_file_metadata = { "offset" : _get_tab_area_vector_definition_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def tab_area_vector_definition_file(self) -> str:
        """Full path of the tabulated area vector definition file."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_tab_area_vector_definition_file_metadata)

    _set_tab_area_vector_definition_file_metadata = { "offset" : _set_tab_area_vector_definition_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @tab_area_vector_definition_file.setter
    def tab_area_vector_definition_file(self, value:str) -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_tab_area_vector_definition_file_metadata, value)

    _get_interpolation_method_metadata = { "offset" : _get_interpolation_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TabVecInterpolationMethod),) }
    @property
    def interpolation_method(self) -> "TabVecInterpolationMethod":
        """Get or set the file interpolation method."""
        return self._intf.get_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._get_interpolation_method_metadata)

    _set_interpolation_method_metadata = { "offset" : _set_interpolation_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TabVecInterpolationMethod),) }
    @interpolation_method.setter
    def interpolation_method(self, value:"TabVecInterpolationMethod") -> None:
        return self._intf.set_property(SRPTabulatedAreaVector._metadata, SRPTabulatedAreaVector._set_interpolation_method_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[mean_flux] = "mean_flux"
    _property_names[luminosity] = "luminosity"
    _property_names[solar_force_method] = "solar_force_method"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"
    _property_names[tab_area_vector_definition_file] = "tab_area_vector_definition_file"
    _property_names[interpolation_method] = "interpolation_method"

    def __init__(self, source_object=None):
        """Construct an object of type SRPTabulatedAreaVector."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPTabulatedAreaVector)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPTabulatedAreaVector, [SRPTabulatedAreaVector, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4701818138234904765, 5913653355719896758), SRPTabulatedAreaVector)
agcls.AgTypeNameMap["SRPTabulatedAreaVector"] = SRPTabulatedAreaVector

class SRPVariableArea(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Variable Area SRP model."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_altitude_method_offset = 1
    _set_atmosphere_altitude_method_offset = 2
    _get_shadow_model_method_offset = 3
    _set_shadow_model_method_offset = 4
    _get_sun_position_method_offset = 5
    _set_sun_position_method_offset = 6
    _get_eclipsing_bodies_method_offset = 7
    _get_mean_flux_method_offset = 8
    _set_mean_flux_method_offset = 9
    _get_luminosity_method_offset = 10
    _set_luminosity_method_offset = 11
    _get_solar_force_method_method_offset = 12
    _set_solar_force_method_method_offset = 13
    _get_include_boundary_mitigation_method_offset = 14
    _set_include_boundary_mitigation_method_offset = 15
    _get_use_sun_central_body_file_values_method_offset = 16
    _set_use_sun_central_body_file_values_method_offset = 17
    _get_solar_radius_method_offset = 18
    _set_solar_radius_method_offset = 19
    _get_variable_area_history_file_method_offset = 20
    _set_variable_area_history_file_method_offset = 21
    _metadata = {
        "iid_data" : (5274748456565795777, 3510230669144871556),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPVariableArea)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_eclipsing_bodies_metadata)

    _get_mean_flux_metadata = { "offset" : _get_mean_flux_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mean_flux(self) -> float:
        """Get or set the mean solar flux at 1 au (W/m^2)."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_mean_flux_metadata)

    _set_mean_flux_metadata = { "offset" : _set_mean_flux_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mean_flux.setter
    def mean_flux(self, value:float) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_mean_flux_metadata, value)

    _get_luminosity_metadata = { "offset" : _get_luminosity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def luminosity(self) -> float:
        """Get or set the luminosity of sun. Dimensionless."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_luminosity_metadata)

    _set_luminosity_metadata = { "offset" : _set_luminosity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @luminosity.setter
    def luminosity(self, value:float) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_luminosity_metadata, value)

    _get_solar_force_method_metadata = { "offset" : _get_solar_force_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @property
    def solar_force_method(self) -> "SolarForceMethod":
        """Get or set the solar force method."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_solar_force_method_metadata)

    _set_solar_force_method_metadata = { "offset" : _set_solar_force_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SolarForceMethod),) }
    @solar_force_method.setter
    def solar_force_method(self, value:"SolarForceMethod") -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_solar_force_method_metadata, value)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar values should come from the Sun.cb file."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get or set the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_solar_radius_metadata, value)

    _get_variable_area_history_file_metadata = { "offset" : _get_variable_area_history_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_area_history_file(self) -> str:
        """Full path of the variable area history file."""
        return self._intf.get_property(SRPVariableArea._metadata, SRPVariableArea._get_variable_area_history_file_metadata)

    _set_variable_area_history_file_metadata = { "offset" : _set_variable_area_history_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_area_history_file.setter
    def variable_area_history_file(self, value:str) -> None:
        return self._intf.set_property(SRPVariableArea._metadata, SRPVariableArea._set_variable_area_history_file_metadata, value)

    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[mean_flux] = "mean_flux"
    _property_names[luminosity] = "luminosity"
    _property_names[solar_force_method] = "solar_force_method"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"
    _property_names[variable_area_history_file] = "variable_area_history_file"

    def __init__(self, source_object=None):
        """Construct an object of type SRPVariableArea."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPVariableArea)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPVariableArea, [SRPVariableArea, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5630766717492279474, 10931366228696915360), SRPVariableArea)
agcls.AgTypeNameMap["SRPVariableArea"] = SRPVariableArea

class ThirdBodyFunction(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Third Body propagator function. The IComponentInfo object returned by the mode property can be cast to GravityFieldFunction or PointMassFunction depending on the selected ModeType."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_third_body_name_method_offset = 1
    _set_third_body_name_method_offset = 2
    _get_ephemeris_source_method_offset = 3
    _set_ephemeris_source_method_offset = 4
    _get_mode_method_offset = 5
    _set_mode_type_method_offset = 6
    _get_mode_type_method_offset = 7
    _get_ephemeris_source_warning_method_offset = 8
    _metadata = {
        "iid_data" : (5266271845857733661, 13603411153532656554),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ThirdBodyFunction)

    _get_third_body_name_metadata = { "offset" : _get_third_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def third_body_name(self) -> str:
        """Get or set the selected third body model."""
        return self._intf.get_property(ThirdBodyFunction._metadata, ThirdBodyFunction._get_third_body_name_metadata)

    _set_third_body_name_metadata = { "offset" : _set_third_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @third_body_name.setter
    def third_body_name(self, value:str) -> None:
        return self._intf.set_property(ThirdBodyFunction._metadata, ThirdBodyFunction._set_third_body_name_metadata, value)

    _get_ephemeris_source_metadata = { "offset" : _get_ephemeris_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EphemerisSource),) }
    @property
    def ephemeris_source(self) -> "EphemerisSource":
        """Source for the third body's ephemeris."""
        return self._intf.get_property(ThirdBodyFunction._metadata, ThirdBodyFunction._get_ephemeris_source_metadata)

    _set_ephemeris_source_metadata = { "offset" : _set_ephemeris_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EphemerisSource),) }
    @ephemeris_source.setter
    def ephemeris_source(self, value:"EphemerisSource") -> None:
        return self._intf.set_property(ThirdBodyFunction._metadata, ThirdBodyFunction._set_ephemeris_source_metadata, value)

    _get_mode_metadata = { "offset" : _get_mode_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode(self) -> "IComponentInfo":
        """Get the third body gravity mode. The IComponentInfo object returned by this property can be cast to GravityFieldFunction or PointMassFunction depending on the selected ModeType."""
        return self._intf.get_property(ThirdBodyFunction._metadata, ThirdBodyFunction._get_mode_metadata)

    _set_mode_type_metadata = { "offset" : _set_mode_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ThirdBodyMode),) }
    def set_mode_type(self, mode:"ThirdBodyMode") -> None:
        """Set the third body gravity mode."""
        return self._intf.invoke(ThirdBodyFunction._metadata, ThirdBodyFunction._set_mode_type_metadata, mode)

    _get_mode_type_metadata = { "offset" : _get_mode_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ThirdBodyMode),) }
    @property
    def mode_type(self) -> "ThirdBodyMode":
        """Get the third body gravity mode type."""
        return self._intf.get_property(ThirdBodyFunction._metadata, ThirdBodyFunction._get_mode_type_metadata)

    _get_ephemeris_source_warning_metadata = { "offset" : _get_ephemeris_source_warning_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def ephemeris_source_warning(self) -> str:
        """Return a warning message if the Ephemeris source and the gravity are not compatible."""
        return self._intf.get_property(ThirdBodyFunction._metadata, ThirdBodyFunction._get_ephemeris_source_warning_metadata)

    _property_names[third_body_name] = "third_body_name"
    _property_names[ephemeris_source] = "ephemeris_source"
    _property_names[mode] = "mode"
    _property_names[mode_type] = "mode_type"
    _property_names[ephemeris_source_warning] = "ephemeris_source_warning"

    def __init__(self, source_object=None):
        """Construct an object of type ThirdBodyFunction."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ThirdBodyFunction)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ThirdBodyFunction, [ThirdBodyFunction, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5428984946557318479, 112860624386267545), ThirdBodyFunction)
agcls.AgTypeNameMap["ThirdBodyFunction"] = ThirdBodyFunction

class DragModelPlugin(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the Drag Model plugin."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_plugin_identifier_method_offset = 1
    _set_plugin_identifier_method_offset = 2
    _get_plugin_config_method_offset = 3
    _metadata = {
        "iid_data" : (4837155914397016406, 9637658823256129943),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DragModelPlugin)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the plugin name."""
        return self._intf.get_property(DragModelPlugin._metadata, DragModelPlugin._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(DragModelPlugin._metadata, DragModelPlugin._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(DragModelPlugin._metadata, DragModelPlugin._get_plugin_config_metadata)

    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"

    def __init__(self, source_object=None):
        """Construct an object of type DragModelPlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DragModelPlugin)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DragModelPlugin, [DragModelPlugin, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5655297245689197224, 4743704511059047083), DragModelPlugin)
agcls.AgTypeNameMap["DragModelPlugin"] = DragModelPlugin

class SRPReflectionPlugin(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the plugin SRP Refelction."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_plugin_identifier_method_offset = 1
    _set_plugin_identifier_method_offset = 2
    _get_plugin_config_method_offset = 3
    _get_atmosphere_altitude_method_offset = 4
    _set_atmosphere_altitude_method_offset = 5
    _get_shadow_model_method_offset = 6
    _set_shadow_model_method_offset = 7
    _get_sun_position_method_offset = 8
    _set_sun_position_method_offset = 9
    _get_eclipsing_bodies_method_offset = 10
    _get_include_boundary_mitigation_method_offset = 11
    _set_include_boundary_mitigation_method_offset = 12
    _get_use_sun_central_body_file_values_method_offset = 13
    _set_use_sun_central_body_file_values_method_offset = 14
    _get_solar_radius_method_offset = 15
    _set_solar_radius_method_offset = 16
    _metadata = {
        "iid_data" : (5650215102850348648, 15657237367331801737),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SRPReflectionPlugin)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the plugin name."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the selected plugin."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_plugin_config_metadata)

    _get_atmosphere_altitude_metadata = { "offset" : _get_atmosphere_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def atmosphere_altitude(self) -> float:
        """Get or set the atmospheric altitude for eclipse. A simple model to account for some measure of attenuation that simply increases the shape of the Earth by the defined altitude height, often taken to be 23 km. Uses Distance Dimension."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_atmosphere_altitude_metadata)

    _set_atmosphere_altitude_metadata = { "offset" : _set_atmosphere_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @atmosphere_altitude.setter
    def atmosphere_altitude(self, value:float) -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_atmosphere_altitude_metadata, value)

    _get_shadow_model_metadata = { "offset" : _get_shadow_model_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @property
    def shadow_model(self) -> "ShadowModel":
        """Get or set the shadow model type."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_shadow_model_metadata)

    _set_shadow_model_metadata = { "offset" : _set_shadow_model_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ShadowModel),) }
    @shadow_model.setter
    def shadow_model(self, value:"ShadowModel") -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_shadow_model_metadata, value)

    _get_sun_position_metadata = { "offset" : _get_sun_position_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @property
    def sun_position(self) -> "SunPosition":
        """Get or set the sun position computation."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_sun_position_metadata)

    _set_sun_position_metadata = { "offset" : _set_sun_position_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SunPosition),) }
    @sun_position.setter
    def sun_position(self, value:"SunPosition") -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_sun_position_metadata, value)

    _get_eclipsing_bodies_metadata = { "offset" : _get_eclipsing_bodies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def eclipsing_bodies(self) -> "CentralBodyComponentCollection":
        """Other eclipsing bodies."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_eclipsing_bodies_metadata)

    _get_include_boundary_mitigation_metadata = { "offset" : _get_include_boundary_mitigation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_boundary_mitigation(self) -> bool:
        """True if shadow boundary mitigation should be performed; the state of the satellite after crossing a shadow boundary will be corrected for errors possibly caused by the sudden change in SRP which occurred during the integration step."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_include_boundary_mitigation_metadata)

    _set_include_boundary_mitigation_metadata = { "offset" : _set_include_boundary_mitigation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_boundary_mitigation.setter
    def include_boundary_mitigation(self, mitigation:bool) -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_include_boundary_mitigation_metadata, mitigation)

    _get_use_sun_central_body_file_values_metadata = { "offset" : _get_use_sun_central_body_file_values_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_sun_central_body_file_values(self) -> bool:
        """True if solar values should come from the Sun.cb file."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_use_sun_central_body_file_values_metadata)

    _set_use_sun_central_body_file_values_metadata = { "offset" : _set_use_sun_central_body_file_values_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_sun_central_body_file_values.setter
    def use_sun_central_body_file_values(self, value:bool) -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_use_sun_central_body_file_values_metadata, value)

    _get_solar_radius_metadata = { "offset" : _get_solar_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def solar_radius(self) -> float:
        """Get the solar radius value to use in eclipse calculations.  Uses Distance Dimension."""
        return self._intf.get_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._get_solar_radius_metadata)

    _set_solar_radius_metadata = { "offset" : _set_solar_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @solar_radius.setter
    def solar_radius(self, value:float) -> None:
        return self._intf.set_property(SRPReflectionPlugin._metadata, SRPReflectionPlugin._set_solar_radius_metadata, value)

    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"
    _property_names[atmosphere_altitude] = "atmosphere_altitude"
    _property_names[shadow_model] = "shadow_model"
    _property_names[sun_position] = "sun_position"
    _property_names[eclipsing_bodies] = "eclipsing_bodies"
    _property_names[include_boundary_mitigation] = "include_boundary_mitigation"
    _property_names[use_sun_central_body_file_values] = "use_sun_central_body_file_values"
    _property_names[solar_radius] = "solar_radius"

    def __init__(self, source_object=None):
        """Construct an object of type SRPReflectionPlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SRPReflectionPlugin)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SRPReflectionPlugin, [SRPReflectionPlugin, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5749102672076773026, 16538708712447368359), SRPReflectionPlugin)
agcls.AgTypeNameMap["SRPReflectionPlugin"] = SRPReflectionPlugin

class EngineConstantAcceleration(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Constant Acceleration and Isp engine model."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_acceleration_method_offset = 3
    _set_acceleration_method_offset = 4
    _get_isp_method_offset = 5
    _set_isp_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (5367865563502630223, 15184193926796654464),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineConstantAcceleration)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._set_g_metadata, value)

    _get_acceleration_metadata = { "offset" : _get_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration(self) -> float:
        """Get or set the acceleration for this engine. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._get_acceleration_metadata)

    _set_acceleration_metadata = { "offset" : _set_acceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration.setter
    def acceleration(self, value:float) -> None:
        return self._intf.set_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._set_acceleration_metadata, value)

    _get_isp_metadata = { "offset" : _get_isp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp(self) -> float:
        """Get or set the specific impulse for this engine. Uses SpecificImpulse Dimension."""
        return self._intf.get_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._get_isp_metadata)

    _set_isp_metadata = { "offset" : _set_isp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp.setter
    def isp(self, value:float) -> None:
        return self._intf.set_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._set_isp_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstantAcceleration),) }
    def enable_control_parameter(self, param:"ControlEngineConstantAcceleration") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineConstantAcceleration._metadata, EngineConstantAcceleration._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstantAcceleration),) }
    def disable_control_parameter(self, param:"ControlEngineConstantAcceleration") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineConstantAcceleration._metadata, EngineConstantAcceleration._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstantAcceleration), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineConstantAcceleration") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineConstantAcceleration._metadata, EngineConstantAcceleration._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineConstantAcceleration._metadata, EngineConstantAcceleration._get_control_parameters_available_metadata)

    _property_names[g] = "g"
    _property_names[acceleration] = "acceleration"
    _property_names[isp] = "isp"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineConstantAcceleration."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineConstantAcceleration)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineConstantAcceleration, [EngineConstantAcceleration, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5132340659530008736, 12633535283190109318), EngineConstantAcceleration)
agcls.AgTypeNameMap["EngineConstantAcceleration"] = EngineConstantAcceleration

class EngineConstant(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Constant Thrust and Isp engine model."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_thrust_method_offset = 3
    _set_thrust_method_offset = 4
    _get_isp_method_offset = 5
    _set_isp_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (5392409510212550659, 12752117697636363187),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineConstant)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineConstant._metadata, EngineConstant._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineConstant._metadata, EngineConstant._set_g_metadata, value)

    _get_thrust_metadata = { "offset" : _get_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def thrust(self) -> float:
        """Get or set the thrust for this engine. Uses Force Dimension."""
        return self._intf.get_property(EngineConstant._metadata, EngineConstant._get_thrust_metadata)

    _set_thrust_metadata = { "offset" : _set_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @thrust.setter
    def thrust(self, value:float) -> None:
        return self._intf.set_property(EngineConstant._metadata, EngineConstant._set_thrust_metadata, value)

    _get_isp_metadata = { "offset" : _get_isp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp(self) -> float:
        """Get or set the specific impulse for this engine. Uses SpecificImpulse Dimension."""
        return self._intf.get_property(EngineConstant._metadata, EngineConstant._get_isp_metadata)

    _set_isp_metadata = { "offset" : _set_isp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp.setter
    def isp(self, value:float) -> None:
        return self._intf.set_property(EngineConstant._metadata, EngineConstant._set_isp_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstant),) }
    def enable_control_parameter(self, param:"ControlEngineConstant") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineConstant._metadata, EngineConstant._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstant),) }
    def disable_control_parameter(self, param:"ControlEngineConstant") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineConstant._metadata, EngineConstant._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineConstant), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineConstant") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineConstant._metadata, EngineConstant._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineConstant._metadata, EngineConstant._get_control_parameters_available_metadata)

    _property_names[g] = "g"
    _property_names[thrust] = "thrust"
    _property_names[isp] = "isp"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineConstant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineConstant)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineConstant, [EngineConstant, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5219754818864697456, 15943359444309466020), EngineConstant)
agcls.AgTypeNameMap["EngineConstant"] = EngineConstant

class EngineIon(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for engine parameters for an Ion engine model."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_input_power_source_name_method_offset = 3
    _set_input_power_source_name_method_offset = 4
    _get_min_required_power_method_offset = 5
    _set_min_required_power_method_offset = 6
    _get_max_input_power_method_offset = 7
    _set_max_input_power_method_offset = 8
    _get_percent_degradation_per_year_method_offset = 9
    _set_percent_degradation_per_year_method_offset = 10
    _get_reference_epoch_method_offset = 11
    _set_reference_epoch_method_offset = 12
    _get_percent_throttle_method_offset = 13
    _set_percent_throttle_method_offset = 14
    _get_engine_definition_method_offset = 15
    _enable_control_parameter_method_offset = 16
    _disable_control_parameter_method_offset = 17
    _is_control_parameter_enabled_method_offset = 18
    _get_control_parameters_available_method_offset = 19
    _metadata = {
        "iid_data" : (4752468591493979126, 10206889890304714890),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineIon)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_g_metadata, value)

    _get_input_power_source_name_metadata = { "offset" : _get_input_power_source_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def input_power_source_name(self) -> str:
        """Get or set the object that computes the power input to the engine."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_input_power_source_name_metadata)

    _set_input_power_source_name_metadata = { "offset" : _set_input_power_source_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @input_power_source_name.setter
    def input_power_source_name(self, power_source:str) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_input_power_source_name_metadata, power_source)

    _get_min_required_power_metadata = { "offset" : _get_min_required_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_required_power(self) -> float:
        """Get or set the minimum power required for engine to produce thrust. Uses Power Dimension."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_min_required_power_metadata)

    _set_min_required_power_metadata = { "offset" : _set_min_required_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_required_power.setter
    def min_required_power(self, value:float) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_min_required_power_metadata, value)

    _get_max_input_power_metadata = { "offset" : _get_max_input_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_input_power(self) -> float:
        """Get or set the maximum power that can be used by engine to produce thrust. Uses Power Dimension."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_max_input_power_metadata)

    _set_max_input_power_metadata = { "offset" : _set_max_input_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_input_power.setter
    def max_input_power(self, value:float) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_max_input_power_metadata, value)

    _get_percent_degradation_per_year_metadata = { "offset" : _get_percent_degradation_per_year_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def percent_degradation_per_year(self) -> float:
        """Get or set the degradation factor is ((1-x%/yr)^(timeSinceRefEpoch))."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_percent_degradation_per_year_metadata)

    _set_percent_degradation_per_year_metadata = { "offset" : _set_percent_degradation_per_year_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @percent_degradation_per_year.setter
    def percent_degradation_per_year(self, value:float) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_percent_degradation_per_year_metadata, value)

    _get_reference_epoch_metadata = { "offset" : _get_reference_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def reference_epoch(self) -> typing.Any:
        """Get or set the date and Time used as reference epoch for degradation. Uses DateFormat Dimension."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_reference_epoch_metadata)

    _set_reference_epoch_metadata = { "offset" : _set_reference_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @reference_epoch.setter
    def reference_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_reference_epoch_metadata, value)

    _get_percent_throttle_metadata = { "offset" : _get_percent_throttle_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def percent_throttle(self) -> float:
        """Get or set the percentage of available thrust to use (100 is full on, 0 is off). Dimensionless."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_percent_throttle_metadata)

    _set_percent_throttle_metadata = { "offset" : _set_percent_throttle_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @percent_throttle.setter
    def percent_throttle(self, value:float) -> None:
        return self._intf.set_property(EngineIon._metadata, EngineIon._set_percent_throttle_metadata, value)

    _get_engine_definition_metadata = { "offset" : _get_engine_definition_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def engine_definition(self) -> "EngineDefinition":
        """Get the engine definition."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_engine_definition_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineIon),) }
    def enable_control_parameter(self, param:"ControlEngineIon") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineIon._metadata, EngineIon._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineIon),) }
    def disable_control_parameter(self, param:"ControlEngineIon") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineIon._metadata, EngineIon._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineIon), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineIon") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineIon._metadata, EngineIon._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineIon._metadata, EngineIon._get_control_parameters_available_metadata)

    _property_names[g] = "g"
    _property_names[input_power_source_name] = "input_power_source_name"
    _property_names[min_required_power] = "min_required_power"
    _property_names[max_input_power] = "max_input_power"
    _property_names[percent_degradation_per_year] = "percent_degradation_per_year"
    _property_names[reference_epoch] = "reference_epoch"
    _property_names[percent_throttle] = "percent_throttle"
    _property_names[engine_definition] = "engine_definition"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineIon."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineIon)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineIon, [EngineIon, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5583107124635364431, 13132643620917133983), EngineIon)
agcls.AgTypeNameMap["EngineIon"] = EngineIon

class EngineThrottleTable(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for engine parameters for a Throttle Table engine model."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_throttle_table_filename_method_offset = 1
    _set_throttle_table_filename_method_offset = 2
    _get_operation_mode_definition_method_offset = 3
    _set_operation_mode_definition_method_offset = 4
    _get_regression_polynomial_degree_method_offset = 5
    _set_regression_polynomial_degree_method_offset = 6
    _get_g_method_offset = 7
    _set_g_method_offset = 8
    _get_input_power_source_name_method_offset = 9
    _set_input_power_source_name_method_offset = 10
    _get_percent_degradation_per_year_method_offset = 11
    _set_percent_degradation_per_year_method_offset = 12
    _get_reference_epoch_method_offset = 13
    _set_reference_epoch_method_offset = 14
    _enable_control_parameter_method_offset = 15
    _disable_control_parameter_method_offset = 16
    _is_control_parameter_enabled_method_offset = 17
    _get_control_parameters_available_method_offset = 18
    _metadata = {
        "iid_data" : (5072248978585673510, 193877365964120460),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineThrottleTable)

    _get_throttle_table_filename_metadata = { "offset" : _get_throttle_table_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def throttle_table_filename(self) -> str:
        """A file containing the engine performance data in the tabular format."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_throttle_table_filename_metadata)

    _set_throttle_table_filename_metadata = { "offset" : _set_throttle_table_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @throttle_table_filename.setter
    def throttle_table_filename(self, value:str) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_throttle_table_filename_metadata, value)

    _get_operation_mode_definition_metadata = { "offset" : _get_operation_mode_definition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ThrottleTableOperationMode),) }
    @property
    def operation_mode_definition(self) -> "ThrottleTableOperationMode":
        """The engine operation mode definition."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_operation_mode_definition_metadata)

    _set_operation_mode_definition_metadata = { "offset" : _set_operation_mode_definition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ThrottleTableOperationMode),) }
    @operation_mode_definition.setter
    def operation_mode_definition(self, value:"ThrottleTableOperationMode") -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_operation_mode_definition_metadata, value)

    _get_regression_polynomial_degree_metadata = { "offset" : _get_regression_polynomial_degree_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def regression_polynomial_degree(self) -> int:
        """The degree of the regression polynomial. Dimensionless."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_regression_polynomial_degree_metadata)

    _set_regression_polynomial_degree_metadata = { "offset" : _set_regression_polynomial_degree_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @regression_polynomial_degree.setter
    def regression_polynomial_degree(self, value:int) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_regression_polynomial_degree_metadata, value)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """The gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_g_metadata, value)

    _get_input_power_source_name_metadata = { "offset" : _get_input_power_source_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def input_power_source_name(self) -> str:
        """The object that computes the power input to the engine."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_input_power_source_name_metadata)

    _set_input_power_source_name_metadata = { "offset" : _set_input_power_source_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @input_power_source_name.setter
    def input_power_source_name(self, power_source:str) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_input_power_source_name_metadata, power_source)

    _get_percent_degradation_per_year_metadata = { "offset" : _get_percent_degradation_per_year_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def percent_degradation_per_year(self) -> float:
        """The degradation factor is ((1-x%/yr)^(timeSinceRefEpoch))."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_percent_degradation_per_year_metadata)

    _set_percent_degradation_per_year_metadata = { "offset" : _set_percent_degradation_per_year_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @percent_degradation_per_year.setter
    def percent_degradation_per_year(self, value:float) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_percent_degradation_per_year_metadata, value)

    _get_reference_epoch_metadata = { "offset" : _get_reference_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def reference_epoch(self) -> typing.Any:
        """The date and Time used as reference epoch for degradation. Uses DateFormat Dimension."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_reference_epoch_metadata)

    _set_reference_epoch_metadata = { "offset" : _set_reference_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @reference_epoch.setter
    def reference_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(EngineThrottleTable._metadata, EngineThrottleTable._set_reference_epoch_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineThrottleTable),) }
    def enable_control_parameter(self, param:"ControlEngineThrottleTable") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineThrottleTable._metadata, EngineThrottleTable._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineThrottleTable),) }
    def disable_control_parameter(self, param:"ControlEngineThrottleTable") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineThrottleTable._metadata, EngineThrottleTable._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineThrottleTable), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineThrottleTable") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineThrottleTable._metadata, EngineThrottleTable._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineThrottleTable._metadata, EngineThrottleTable._get_control_parameters_available_metadata)

    _property_names[throttle_table_filename] = "throttle_table_filename"
    _property_names[operation_mode_definition] = "operation_mode_definition"
    _property_names[regression_polynomial_degree] = "regression_polynomial_degree"
    _property_names[g] = "g"
    _property_names[input_power_source_name] = "input_power_source_name"
    _property_names[percent_degradation_per_year] = "percent_degradation_per_year"
    _property_names[reference_epoch] = "reference_epoch"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineThrottleTable."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineThrottleTable)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineThrottleTable, [EngineThrottleTable, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5708677625607910551, 6846267070543381145), EngineThrottleTable)
agcls.AgTypeNameMap["EngineThrottleTable"] = EngineThrottleTable

class EngineCustom(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Custom engine model."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_eval_function_name_method_offset = 3
    _set_eval_function_name_method_offset = 4
    _get_post_function_name_method_offset = 5
    _set_post_function_name_method_offset = 6
    _get_pre_function_name_method_offset = 7
    _set_pre_function_name_method_offset = 8
    _get_seg_start_function_name_method_offset = 9
    _set_seg_start_function_name_method_offset = 10
    _get_update_function_name_method_offset = 11
    _set_update_function_name_method_offset = 12
    _enable_control_parameter_method_offset = 13
    _disable_control_parameter_method_offset = 14
    _is_control_parameter_enabled_method_offset = 15
    _get_control_parameters_available_method_offset = 16
    _metadata = {
        "iid_data" : (5506674519985653951, 2933120803682579083),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineCustom)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the earth surface gravity acceleration for Isp conversions. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_g_metadata, value)

    _get_eval_function_name_metadata = { "offset" : _get_eval_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def eval_function_name(self) -> str:
        """Get or set the EvalFunction - custom function to call at every thrust evaluation."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_eval_function_name_metadata)

    _set_eval_function_name_metadata = { "offset" : _set_eval_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @eval_function_name.setter
    def eval_function_name(self, eval_function:str) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_eval_function_name_metadata, eval_function)

    _get_post_function_name_metadata = { "offset" : _get_post_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def post_function_name(self) -> str:
        """Get or set the PostFunction - custom function to call after all propagation ends."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_post_function_name_metadata)

    _set_post_function_name_metadata = { "offset" : _set_post_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @post_function_name.setter
    def post_function_name(self, post_function:str) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_post_function_name_metadata, post_function)

    _get_pre_function_name_metadata = { "offset" : _get_pre_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def pre_function_name(self) -> str:
        """Get or set the PreFunction - custom function to call before any propagation begins."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_pre_function_name_metadata)

    _set_pre_function_name_metadata = { "offset" : _set_pre_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @pre_function_name.setter
    def pre_function_name(self, pre_function:str) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_pre_function_name_metadata, pre_function)

    _get_seg_start_function_name_metadata = { "offset" : _get_seg_start_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def seg_start_function_name(self) -> str:
        """Get or set the SegStartFunction - custom function to call at the beginning of each segment."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_seg_start_function_name_metadata)

    _set_seg_start_function_name_metadata = { "offset" : _set_seg_start_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @seg_start_function_name.setter
    def seg_start_function_name(self, seg_start_function:str) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_seg_start_function_name_metadata, seg_start_function)

    _get_update_function_name_metadata = { "offset" : _get_update_function_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def update_function_name(self) -> str:
        """Get or set the UpdateFunction - custom function to call at the beginning of each integration step."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_update_function_name_metadata)

    _set_update_function_name_metadata = { "offset" : _set_update_function_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @update_function_name.setter
    def update_function_name(self, update_function:str) -> None:
        return self._intf.set_property(EngineCustom._metadata, EngineCustom._set_update_function_name_metadata, update_function)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineCustom),) }
    def enable_control_parameter(self, param:"ControlEngineCustom") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineCustom._metadata, EngineCustom._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineCustom),) }
    def disable_control_parameter(self, param:"ControlEngineCustom") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineCustom._metadata, EngineCustom._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineCustom), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineCustom") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineCustom._metadata, EngineCustom._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineCustom._metadata, EngineCustom._get_control_parameters_available_metadata)

    _property_names[g] = "g"
    _property_names[eval_function_name] = "eval_function_name"
    _property_names[post_function_name] = "post_function_name"
    _property_names[pre_function_name] = "pre_function_name"
    _property_names[seg_start_function_name] = "seg_start_function_name"
    _property_names[update_function_name] = "update_function_name"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineCustom."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineCustom)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineCustom, [EngineCustom, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5466003591225632718, 10242738978556827264), EngineCustom)
agcls.AgTypeNameMap["EngineCustom"] = EngineCustom

class EnginePlugin(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Plugin engine model."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_plugin_identifier_method_offset = 3
    _set_plugin_identifier_method_offset = 4
    _get_plugin_config_method_offset = 5
    _metadata = {
        "iid_data" : (5229149442286645775, 6989938573706770849),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EnginePlugin)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EnginePlugin._metadata, EnginePlugin._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EnginePlugin._metadata, EnginePlugin._set_g_metadata, value)

    _get_plugin_identifier_metadata = { "offset" : _get_plugin_identifier_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def plugin_identifier(self) -> str:
        """Get or set the PluginIdentifier - the ProgID of the COM component you are using for this model."""
        return self._intf.get_property(EnginePlugin._metadata, EnginePlugin._get_plugin_identifier_metadata)

    _set_plugin_identifier_metadata = { "offset" : _set_plugin_identifier_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @plugin_identifier.setter
    def plugin_identifier(self, value:str) -> None:
        return self._intf.set_property(EnginePlugin._metadata, EnginePlugin._set_plugin_identifier_metadata, value)

    _get_plugin_config_metadata = { "offset" : _get_plugin_config_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def plugin_config(self) -> "PluginProperties":
        """Get the properties of the plugin."""
        return self._intf.get_property(EnginePlugin._metadata, EnginePlugin._get_plugin_config_metadata)

    _property_names[g] = "g"
    _property_names[plugin_identifier] = "plugin_identifier"
    _property_names[plugin_config] = "plugin_config"

    def __init__(self, source_object=None):
        """Construct an object of type EnginePlugin."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EnginePlugin)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EnginePlugin, [EnginePlugin, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5599410985521995715, 2643318681551189431), EnginePlugin)
agcls.AgTypeNameMap["EnginePlugin"] = EnginePlugin

class EngineModelPolynomial(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a Polynomial Thrust and Isp engine model."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_g_method_offset = 1
    _set_g_method_offset = 2
    _get_thrust_coefficients_method_offset = 3
    _get_isp_coefficients_method_offset = 4
    _enable_control_parameter_method_offset = 5
    _disable_control_parameter_method_offset = 6
    _is_control_parameter_enabled_method_offset = 7
    _get_control_parameters_available_method_offset = 8
    _metadata = {
        "iid_data" : (5059507493538489712, 6563525814359022262),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineModelPolynomial)

    _get_g_metadata = { "offset" : _get_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def g(self) -> float:
        """Get or set the gravitational acceleration constant at sea level on the Earth. Uses Acceleration Dimension."""
        return self._intf.get_property(EngineModelPolynomial._metadata, EngineModelPolynomial._get_g_metadata)

    _set_g_metadata = { "offset" : _set_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @g.setter
    def g(self, value:float) -> None:
        return self._intf.set_property(EngineModelPolynomial._metadata, EngineModelPolynomial._set_g_metadata, value)

    _get_thrust_coefficients_metadata = { "offset" : _get_thrust_coefficients_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def thrust_coefficients(self) -> "EngineModelThrustCoefficients":
        """Get the thrust Coefficients."""
        return self._intf.get_property(EngineModelPolynomial._metadata, EngineModelPolynomial._get_thrust_coefficients_metadata)

    _get_isp_coefficients_metadata = { "offset" : _get_isp_coefficients_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def isp_coefficients(self) -> "EngineModelIspCoefficients":
        """Get the Isp Coefficients."""
        return self._intf.get_property(EngineModelPolynomial._metadata, EngineModelPolynomial._get_isp_coefficients_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineModelPolynomial),) }
    def enable_control_parameter(self, param:"ControlEngineModelPolynomial") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(EngineModelPolynomial._metadata, EngineModelPolynomial._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlEngineModelPolynomial),) }
    def disable_control_parameter(self, param:"ControlEngineModelPolynomial") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(EngineModelPolynomial._metadata, EngineModelPolynomial._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlEngineModelPolynomial), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlEngineModelPolynomial") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(EngineModelPolynomial._metadata, EngineModelPolynomial._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(EngineModelPolynomial._metadata, EngineModelPolynomial._get_control_parameters_available_metadata)

    _property_names[g] = "g"
    _property_names[thrust_coefficients] = "thrust_coefficients"
    _property_names[isp_coefficients] = "isp_coefficients"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type EngineModelPolynomial."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineModelPolynomial)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineModelPolynomial, [EngineModelPolynomial, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4861258356240938548, 15888178850114875033), EngineModelPolynomial)
agcls.AgTypeNameMap["EngineModelPolynomial"] = EngineModelPolynomial

class EngineModelThrustCoefficients(SupportsDeleteCallback):
    """Thrust coefficient properties for engine definition."""

    _num_methods = 32
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_c0_method_offset = 1
    _set_c0_method_offset = 2
    _get_c1_method_offset = 3
    _set_c1_method_offset = 4
    _get_c2_method_offset = 5
    _set_c2_method_offset = 6
    _get_c3_method_offset = 7
    _set_c3_method_offset = 8
    _get_c4_method_offset = 9
    _set_c4_method_offset = 10
    _get_c5_method_offset = 11
    _set_c5_method_offset = 12
    _get_c6_method_offset = 13
    _set_c6_method_offset = 14
    _get_c7_method_offset = 15
    _set_c7_method_offset = 16
    _get_e4_method_offset = 17
    _set_e4_method_offset = 18
    _get_e5_method_offset = 19
    _set_e5_method_offset = 20
    _get_e6_method_offset = 21
    _set_e6_method_offset = 22
    _get_e7_method_offset = 23
    _set_e7_method_offset = 24
    _get_b7_method_offset = 25
    _set_b7_method_offset = 26
    _get_k0_method_offset = 27
    _set_k0_method_offset = 28
    _get_k1_method_offset = 29
    _set_k1_method_offset = 30
    _get_reference_temp_method_offset = 31
    _set_reference_temp_method_offset = 32
    _metadata = {
        "iid_data" : (5296036972774579420, 11767688325395047045),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineModelThrustCoefficients)

    _get_c0_metadata = { "offset" : _get_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c0(self) -> float:
        """C0 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c0_metadata)

    _set_c0_metadata = { "offset" : _set_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c0.setter
    def c0(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c0_metadata, value)

    _get_c1_metadata = { "offset" : _get_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c1(self) -> float:
        """C1 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c1_metadata)

    _set_c1_metadata = { "offset" : _set_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c1.setter
    def c1(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c1_metadata, value)

    _get_c2_metadata = { "offset" : _get_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c2(self) -> float:
        """C2 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c2_metadata)

    _set_c2_metadata = { "offset" : _set_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c2.setter
    def c2(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c2_metadata, value)

    _get_c3_metadata = { "offset" : _get_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c3(self) -> float:
        """C3 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c3_metadata)

    _set_c3_metadata = { "offset" : _set_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c3.setter
    def c3(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c3_metadata, value)

    _get_c4_metadata = { "offset" : _get_c4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c4(self) -> float:
        """C4 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c4_metadata)

    _set_c4_metadata = { "offset" : _set_c4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c4.setter
    def c4(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c4_metadata, value)

    _get_c5_metadata = { "offset" : _get_c5_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c5(self) -> float:
        """C5 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c5_metadata)

    _set_c5_metadata = { "offset" : _set_c5_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c5.setter
    def c5(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c5_metadata, value)

    _get_c6_metadata = { "offset" : _get_c6_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c6(self) -> float:
        """C6 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c6_metadata)

    _set_c6_metadata = { "offset" : _set_c6_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c6.setter
    def c6(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c6_metadata, value)

    _get_c7_metadata = { "offset" : _get_c7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c7(self) -> float:
        """C7 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_c7_metadata)

    _set_c7_metadata = { "offset" : _set_c7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c7.setter
    def c7(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_c7_metadata, value)

    _get_e4_metadata = { "offset" : _get_e4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e4(self) -> float:
        """E4 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_e4_metadata)

    _set_e4_metadata = { "offset" : _set_e4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e4.setter
    def e4(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_e4_metadata, value)

    _get_e5_metadata = { "offset" : _get_e5_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e5(self) -> float:
        """E5 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_e5_metadata)

    _set_e5_metadata = { "offset" : _set_e5_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e5.setter
    def e5(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_e5_metadata, value)

    _get_e6_metadata = { "offset" : _get_e6_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e6(self) -> float:
        """E6 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_e6_metadata)

    _set_e6_metadata = { "offset" : _set_e6_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e6.setter
    def e6(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_e6_metadata, value)

    _get_e7_metadata = { "offset" : _get_e7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e7(self) -> float:
        """E7 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_e7_metadata)

    _set_e7_metadata = { "offset" : _set_e7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e7.setter
    def e7(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_e7_metadata, value)

    _get_b7_metadata = { "offset" : _get_b7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b7(self) -> float:
        """B7 base. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_b7_metadata)

    _set_b7_metadata = { "offset" : _set_b7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b7.setter
    def b7(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_b7_metadata, value)

    _get_k0_metadata = { "offset" : _get_k0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k0(self) -> float:
        """K0 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_k0_metadata)

    _set_k0_metadata = { "offset" : _set_k0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k0.setter
    def k0(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_k0_metadata, value)

    _get_k1_metadata = { "offset" : _get_k1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k1(self) -> float:
        """K1 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_k1_metadata)

    _set_k1_metadata = { "offset" : _set_k1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k1.setter
    def k1(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_k1_metadata, value)

    _get_reference_temp_metadata = { "offset" : _get_reference_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_temp(self) -> float:
        """Reference temperature for data. Uses Temperature Dimension."""
        return self._intf.get_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._get_reference_temp_metadata)

    _set_reference_temp_metadata = { "offset" : _set_reference_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_temp.setter
    def reference_temp(self, value:float) -> None:
        return self._intf.set_property(EngineModelThrustCoefficients._metadata, EngineModelThrustCoefficients._set_reference_temp_metadata, value)

    _property_names[c0] = "c0"
    _property_names[c1] = "c1"
    _property_names[c2] = "c2"
    _property_names[c3] = "c3"
    _property_names[c4] = "c4"
    _property_names[c5] = "c5"
    _property_names[c6] = "c6"
    _property_names[c7] = "c7"
    _property_names[e4] = "e4"
    _property_names[e5] = "e5"
    _property_names[e6] = "e6"
    _property_names[e7] = "e7"
    _property_names[b7] = "b7"
    _property_names[k0] = "k0"
    _property_names[k1] = "k1"
    _property_names[reference_temp] = "reference_temp"

    def __init__(self, source_object=None):
        """Construct an object of type EngineModelThrustCoefficients."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineModelThrustCoefficients)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineModelThrustCoefficients, [EngineModelThrustCoefficients, ])

agcls.AgClassCatalog.add_catalog_entry((5353637564824579689, 8119903029500529314), EngineModelThrustCoefficients)
agcls.AgTypeNameMap["EngineModelThrustCoefficients"] = EngineModelThrustCoefficients

class EngineModelIspCoefficients(SupportsDeleteCallback):
    """Isp coefficient properties for engine definition."""

    _num_methods = 32
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_c0_method_offset = 1
    _set_c0_method_offset = 2
    _get_c1_method_offset = 3
    _set_c1_method_offset = 4
    _get_c2_method_offset = 5
    _set_c2_method_offset = 6
    _get_c3_method_offset = 7
    _set_c3_method_offset = 8
    _get_c4_method_offset = 9
    _set_c4_method_offset = 10
    _get_c5_method_offset = 11
    _set_c5_method_offset = 12
    _get_c6_method_offset = 13
    _set_c6_method_offset = 14
    _get_c7_method_offset = 15
    _set_c7_method_offset = 16
    _get_e4_method_offset = 17
    _set_e4_method_offset = 18
    _get_e5_method_offset = 19
    _set_e5_method_offset = 20
    _get_e6_method_offset = 21
    _set_e6_method_offset = 22
    _get_e7_method_offset = 23
    _set_e7_method_offset = 24
    _get_b7_method_offset = 25
    _set_b7_method_offset = 26
    _get_k0_method_offset = 27
    _set_k0_method_offset = 28
    _get_k1_method_offset = 29
    _set_k1_method_offset = 30
    _get_reference_temp_method_offset = 31
    _set_reference_temp_method_offset = 32
    _metadata = {
        "iid_data" : (5713640319682686971, 10102400234203899284),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineModelIspCoefficients)

    _get_c0_metadata = { "offset" : _get_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c0(self) -> float:
        """C0 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c0_metadata)

    _set_c0_metadata = { "offset" : _set_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c0.setter
    def c0(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c0_metadata, value)

    _get_c1_metadata = { "offset" : _get_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c1(self) -> float:
        """C1 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c1_metadata)

    _set_c1_metadata = { "offset" : _set_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c1.setter
    def c1(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c1_metadata, value)

    _get_c2_metadata = { "offset" : _get_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c2(self) -> float:
        """C2 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c2_metadata)

    _set_c2_metadata = { "offset" : _set_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c2.setter
    def c2(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c2_metadata, value)

    _get_c3_metadata = { "offset" : _get_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c3(self) -> float:
        """C3 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c3_metadata)

    _set_c3_metadata = { "offset" : _set_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c3.setter
    def c3(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c3_metadata, value)

    _get_c4_metadata = { "offset" : _get_c4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c4(self) -> float:
        """C4 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c4_metadata)

    _set_c4_metadata = { "offset" : _set_c4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c4.setter
    def c4(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c4_metadata, value)

    _get_c5_metadata = { "offset" : _get_c5_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c5(self) -> float:
        """C5 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c5_metadata)

    _set_c5_metadata = { "offset" : _set_c5_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c5.setter
    def c5(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c5_metadata, value)

    _get_c6_metadata = { "offset" : _get_c6_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c6(self) -> float:
        """C6 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c6_metadata)

    _set_c6_metadata = { "offset" : _set_c6_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c6.setter
    def c6(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c6_metadata, value)

    _get_c7_metadata = { "offset" : _get_c7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def c7(self) -> float:
        """C7 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_c7_metadata)

    _set_c7_metadata = { "offset" : _set_c7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @c7.setter
    def c7(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_c7_metadata, value)

    _get_e4_metadata = { "offset" : _get_e4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e4(self) -> float:
        """E4 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_e4_metadata)

    _set_e4_metadata = { "offset" : _set_e4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e4.setter
    def e4(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_e4_metadata, value)

    _get_e5_metadata = { "offset" : _get_e5_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e5(self) -> float:
        """E5 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_e5_metadata)

    _set_e5_metadata = { "offset" : _set_e5_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e5.setter
    def e5(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_e5_metadata, value)

    _get_e6_metadata = { "offset" : _get_e6_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e6(self) -> float:
        """E6 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_e6_metadata)

    _set_e6_metadata = { "offset" : _set_e6_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e6.setter
    def e6(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_e6_metadata, value)

    _get_e7_metadata = { "offset" : _get_e7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def e7(self) -> float:
        """E7 exponent. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_e7_metadata)

    _set_e7_metadata = { "offset" : _set_e7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @e7.setter
    def e7(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_e7_metadata, value)

    _get_b7_metadata = { "offset" : _get_b7_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def b7(self) -> float:
        """B7 base. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_b7_metadata)

    _set_b7_metadata = { "offset" : _set_b7_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @b7.setter
    def b7(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_b7_metadata, value)

    _get_k0_metadata = { "offset" : _get_k0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k0(self) -> float:
        """K0 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_k0_metadata)

    _set_k0_metadata = { "offset" : _set_k0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k0.setter
    def k0(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_k0_metadata, value)

    _get_k1_metadata = { "offset" : _get_k1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def k1(self) -> float:
        """K1 coefficient. Dimensionless."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_k1_metadata)

    _set_k1_metadata = { "offset" : _set_k1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @k1.setter
    def k1(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_k1_metadata, value)

    _get_reference_temp_metadata = { "offset" : _get_reference_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_temp(self) -> float:
        """Reference temperature for data. Uses Temperature Dimension."""
        return self._intf.get_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._get_reference_temp_metadata)

    _set_reference_temp_metadata = { "offset" : _set_reference_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_temp.setter
    def reference_temp(self, value:float) -> None:
        return self._intf.set_property(EngineModelIspCoefficients._metadata, EngineModelIspCoefficients._set_reference_temp_metadata, value)

    _property_names[c0] = "c0"
    _property_names[c1] = "c1"
    _property_names[c2] = "c2"
    _property_names[c3] = "c3"
    _property_names[c4] = "c4"
    _property_names[c5] = "c5"
    _property_names[c6] = "c6"
    _property_names[c7] = "c7"
    _property_names[e4] = "e4"
    _property_names[e5] = "e5"
    _property_names[e6] = "e6"
    _property_names[e7] = "e7"
    _property_names[b7] = "b7"
    _property_names[k0] = "k0"
    _property_names[k1] = "k1"
    _property_names[reference_temp] = "reference_temp"

    def __init__(self, source_object=None):
        """Construct an object of type EngineModelIspCoefficients."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineModelIspCoefficients)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineModelIspCoefficients, [EngineModelIspCoefficients, ])

agcls.AgClassCatalog.add_catalog_entry((4992422672175141294, 2073381080858427796), EngineModelIspCoefficients)
agcls.AgTypeNameMap["EngineModelIspCoefficients"] = EngineModelIspCoefficients

class EngineDefinition(SupportsDeleteCallback):
    """Properties for engine definition for an Ion engine model."""

    _num_methods = 42
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_isp_c0_method_offset = 1
    _set_isp_c0_method_offset = 2
    _get_isp_c1_method_offset = 3
    _set_isp_c1_method_offset = 4
    _get_isp_c2_method_offset = 5
    _set_isp_c2_method_offset = 6
    _get_isp_c3_method_offset = 7
    _set_isp_c3_method_offset = 8
    _get_mass_flow_rate_equation_type_method_offset = 9
    _set_mass_flow_rate_equation_type_method_offset = 10
    _get_mass_flow_rate_c0_method_offset = 11
    _set_mass_flow_rate_c0_method_offset = 12
    _get_mass_flow_rate_c1_method_offset = 13
    _set_mass_flow_rate_c1_method_offset = 14
    _get_mass_flow_rate_c2_method_offset = 15
    _set_mass_flow_rate_c2_method_offset = 16
    _get_mass_flow_rate_c3_method_offset = 17
    _set_mass_flow_rate_c3_method_offset = 18
    _get_mass_flow_rate_equation_method_offset = 19
    _get_mass_flow_efficiency_c0_method_offset = 20
    _set_mass_flow_efficiency_c0_method_offset = 21
    _get_mass_flow_efficiency_c1_method_offset = 22
    _set_mass_flow_efficiency_c1_method_offset = 23
    _get_mass_flow_efficiency_c2_method_offset = 24
    _set_mass_flow_efficiency_c2_method_offset = 25
    _get_mass_flow_efficiency_c3_method_offset = 26
    _set_mass_flow_efficiency_c3_method_offset = 27
    _get_mass_flow_efficiency_independent_var_method_offset = 28
    _set_mass_flow_efficiency_independent_var_method_offset = 29
    _get_mass_flow_efficiency_equation_method_offset = 30
    _get_power_efficiency_c0_method_offset = 31
    _set_power_efficiency_c0_method_offset = 32
    _get_power_efficiency_c1_method_offset = 33
    _set_power_efficiency_c1_method_offset = 34
    _get_power_efficiency_c2_method_offset = 35
    _set_power_efficiency_c2_method_offset = 36
    _get_power_efficiency_c3_method_offset = 37
    _set_power_efficiency_c3_method_offset = 38
    _get_power_efficiency_independent_var_method_offset = 39
    _set_power_efficiency_independent_var_method_offset = 40
    _get_power_efficiency_equation_method_offset = 41
    _get_input_power_source_name_method_offset = 42
    _metadata = {
        "iid_data" : (5036043198846161417, 5153337819751964810),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EngineDefinition)

    _get_isp_c0_metadata = { "offset" : _get_isp_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp_c0(self) -> float:
        """Get or set the constant coefficient (C0). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_isp_c0_metadata)

    _set_isp_c0_metadata = { "offset" : _set_isp_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp_c0.setter
    def isp_c0(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_isp_c0_metadata, value)

    _get_isp_c1_metadata = { "offset" : _get_isp_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp_c1(self) -> float:
        """Get or set the linear coefficient (C1). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_isp_c1_metadata)

    _set_isp_c1_metadata = { "offset" : _set_isp_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp_c1.setter
    def isp_c1(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_isp_c1_metadata, value)

    _get_isp_c2_metadata = { "offset" : _get_isp_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp_c2(self) -> float:
        """Get or set the quadratic coefficient (C2). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_isp_c2_metadata)

    _set_isp_c2_metadata = { "offset" : _set_isp_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp_c2.setter
    def isp_c2(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_isp_c2_metadata, value)

    _get_isp_c3_metadata = { "offset" : _get_isp_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def isp_c3(self) -> float:
        """Get or set the cubic coefficient (C3). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_isp_c3_metadata)

    _set_isp_c3_metadata = { "offset" : _set_isp_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @isp_c3.setter
    def isp_c3(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_isp_c3_metadata, value)

    _get_mass_flow_rate_equation_type_metadata = { "offset" : _get_mass_flow_rate_equation_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @property
    def mass_flow_rate_equation_type(self) -> "EngineModelFunction":
        """Get or set the independent variable for the mass flow rate equation."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_equation_type_metadata)

    _set_mass_flow_rate_equation_type_metadata = { "offset" : _set_mass_flow_rate_equation_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @mass_flow_rate_equation_type.setter
    def mass_flow_rate_equation_type(self, value:"EngineModelFunction") -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_rate_equation_type_metadata, value)

    _get_mass_flow_rate_c0_metadata = { "offset" : _get_mass_flow_rate_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_rate_c0(self) -> float:
        """Get or set the constant coefficient (C0). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_c0_metadata)

    _set_mass_flow_rate_c0_metadata = { "offset" : _set_mass_flow_rate_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_rate_c0.setter
    def mass_flow_rate_c0(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_rate_c0_metadata, value)

    _get_mass_flow_rate_c1_metadata = { "offset" : _get_mass_flow_rate_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_rate_c1(self) -> float:
        """Get or set the linear coefficient (C1). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_c1_metadata)

    _set_mass_flow_rate_c1_metadata = { "offset" : _set_mass_flow_rate_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_rate_c1.setter
    def mass_flow_rate_c1(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_rate_c1_metadata, value)

    _get_mass_flow_rate_c2_metadata = { "offset" : _get_mass_flow_rate_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_rate_c2(self) -> float:
        """Get or set the quadratic coefficient (C2). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_c2_metadata)

    _set_mass_flow_rate_c2_metadata = { "offset" : _set_mass_flow_rate_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_rate_c2.setter
    def mass_flow_rate_c2(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_rate_c2_metadata, value)

    _get_mass_flow_rate_c3_metadata = { "offset" : _get_mass_flow_rate_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_rate_c3(self) -> float:
        """Get or set the cubic coefficient (C3). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_c3_metadata)

    _set_mass_flow_rate_c3_metadata = { "offset" : _set_mass_flow_rate_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_rate_c3.setter
    def mass_flow_rate_c3(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_rate_c3_metadata, value)

    _get_mass_flow_rate_equation_metadata = { "offset" : _get_mass_flow_rate_equation_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def mass_flow_rate_equation(self) -> str:
        """Get the equation for mass flow rate."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_rate_equation_metadata)

    _get_mass_flow_efficiency_c0_metadata = { "offset" : _get_mass_flow_efficiency_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_efficiency_c0(self) -> float:
        """Get or set the constant coefficient (C0). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_c0_metadata)

    _set_mass_flow_efficiency_c0_metadata = { "offset" : _set_mass_flow_efficiency_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_efficiency_c0.setter
    def mass_flow_efficiency_c0(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_efficiency_c0_metadata, value)

    _get_mass_flow_efficiency_c1_metadata = { "offset" : _get_mass_flow_efficiency_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_efficiency_c1(self) -> float:
        """Get or set the linear coefficient (C1). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_c1_metadata)

    _set_mass_flow_efficiency_c1_metadata = { "offset" : _set_mass_flow_efficiency_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_efficiency_c1.setter
    def mass_flow_efficiency_c1(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_efficiency_c1_metadata, value)

    _get_mass_flow_efficiency_c2_metadata = { "offset" : _get_mass_flow_efficiency_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_efficiency_c2(self) -> float:
        """Get or set the quadratic coefficient (C2). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_c2_metadata)

    _set_mass_flow_efficiency_c2_metadata = { "offset" : _set_mass_flow_efficiency_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_efficiency_c2.setter
    def mass_flow_efficiency_c2(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_efficiency_c2_metadata, value)

    _get_mass_flow_efficiency_c3_metadata = { "offset" : _get_mass_flow_efficiency_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_flow_efficiency_c3(self) -> float:
        """Get or set the cubic coefficient (C3). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_c3_metadata)

    _set_mass_flow_efficiency_c3_metadata = { "offset" : _set_mass_flow_efficiency_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mass_flow_efficiency_c3.setter
    def mass_flow_efficiency_c3(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_efficiency_c3_metadata, value)

    _get_mass_flow_efficiency_independent_var_metadata = { "offset" : _get_mass_flow_efficiency_independent_var_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @property
    def mass_flow_efficiency_independent_var(self) -> "EngineModelFunction":
        """Get or set the independent variable for the mass flow efficiency equation."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_independent_var_metadata)

    _set_mass_flow_efficiency_independent_var_metadata = { "offset" : _set_mass_flow_efficiency_independent_var_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @mass_flow_efficiency_independent_var.setter
    def mass_flow_efficiency_independent_var(self, value:"EngineModelFunction") -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_mass_flow_efficiency_independent_var_metadata, value)

    _get_mass_flow_efficiency_equation_metadata = { "offset" : _get_mass_flow_efficiency_equation_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def mass_flow_efficiency_equation(self) -> str:
        """Get the equation for mass flow efficiency."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_mass_flow_efficiency_equation_metadata)

    _get_power_efficiency_c0_metadata = { "offset" : _get_power_efficiency_c0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def power_efficiency_c0(self) -> float:
        """Get or set the constant coefficient (C0). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_c0_metadata)

    _set_power_efficiency_c0_metadata = { "offset" : _set_power_efficiency_c0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @power_efficiency_c0.setter
    def power_efficiency_c0(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_power_efficiency_c0_metadata, value)

    _get_power_efficiency_c1_metadata = { "offset" : _get_power_efficiency_c1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def power_efficiency_c1(self) -> float:
        """Get or set the linear coefficient (C1). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_c1_metadata)

    _set_power_efficiency_c1_metadata = { "offset" : _set_power_efficiency_c1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @power_efficiency_c1.setter
    def power_efficiency_c1(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_power_efficiency_c1_metadata, value)

    _get_power_efficiency_c2_metadata = { "offset" : _get_power_efficiency_c2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def power_efficiency_c2(self) -> float:
        """Get or set the quadratic coefficient (C2). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_c2_metadata)

    _set_power_efficiency_c2_metadata = { "offset" : _set_power_efficiency_c2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @power_efficiency_c2.setter
    def power_efficiency_c2(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_power_efficiency_c2_metadata, value)

    _get_power_efficiency_c3_metadata = { "offset" : _get_power_efficiency_c3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def power_efficiency_c3(self) -> float:
        """Get or set the cubic coefficient (C3). Dimensionless."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_c3_metadata)

    _set_power_efficiency_c3_metadata = { "offset" : _set_power_efficiency_c3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @power_efficiency_c3.setter
    def power_efficiency_c3(self, value:float) -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_power_efficiency_c3_metadata, value)

    _get_power_efficiency_independent_var_metadata = { "offset" : _get_power_efficiency_independent_var_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @property
    def power_efficiency_independent_var(self) -> "EngineModelFunction":
        """Get or set the independent variable for the power efficiency equation."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_independent_var_metadata)

    _set_power_efficiency_independent_var_metadata = { "offset" : _set_power_efficiency_independent_var_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EngineModelFunction),) }
    @power_efficiency_independent_var.setter
    def power_efficiency_independent_var(self, value:"EngineModelFunction") -> None:
        return self._intf.set_property(EngineDefinition._metadata, EngineDefinition._set_power_efficiency_independent_var_metadata, value)

    _get_power_efficiency_equation_metadata = { "offset" : _get_power_efficiency_equation_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def power_efficiency_equation(self) -> str:
        """Get the equation for power efficiency."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_power_efficiency_equation_metadata)

    _get_input_power_source_name_metadata = { "offset" : _get_input_power_source_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def input_power_source_name(self) -> str:
        """Object that computes the power input to the engine."""
        return self._intf.get_property(EngineDefinition._metadata, EngineDefinition._get_input_power_source_name_metadata)

    _property_names[isp_c0] = "isp_c0"
    _property_names[isp_c1] = "isp_c1"
    _property_names[isp_c2] = "isp_c2"
    _property_names[isp_c3] = "isp_c3"
    _property_names[mass_flow_rate_equation_type] = "mass_flow_rate_equation_type"
    _property_names[mass_flow_rate_c0] = "mass_flow_rate_c0"
    _property_names[mass_flow_rate_c1] = "mass_flow_rate_c1"
    _property_names[mass_flow_rate_c2] = "mass_flow_rate_c2"
    _property_names[mass_flow_rate_c3] = "mass_flow_rate_c3"
    _property_names[mass_flow_rate_equation] = "mass_flow_rate_equation"
    _property_names[mass_flow_efficiency_c0] = "mass_flow_efficiency_c0"
    _property_names[mass_flow_efficiency_c1] = "mass_flow_efficiency_c1"
    _property_names[mass_flow_efficiency_c2] = "mass_flow_efficiency_c2"
    _property_names[mass_flow_efficiency_c3] = "mass_flow_efficiency_c3"
    _property_names[mass_flow_efficiency_independent_var] = "mass_flow_efficiency_independent_var"
    _property_names[mass_flow_efficiency_equation] = "mass_flow_efficiency_equation"
    _property_names[power_efficiency_c0] = "power_efficiency_c0"
    _property_names[power_efficiency_c1] = "power_efficiency_c1"
    _property_names[power_efficiency_c2] = "power_efficiency_c2"
    _property_names[power_efficiency_c3] = "power_efficiency_c3"
    _property_names[power_efficiency_independent_var] = "power_efficiency_independent_var"
    _property_names[power_efficiency_equation] = "power_efficiency_equation"
    _property_names[input_power_source_name] = "input_power_source_name"

    def __init__(self, source_object=None):
        """Construct an object of type EngineDefinition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EngineDefinition)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EngineDefinition, [EngineDefinition, ])

agcls.AgClassCatalog.add_catalog_entry((5393150563279186375, 13009477743191425412), EngineDefinition)
agcls.AgTypeNameMap["EngineDefinition"] = EngineDefinition

class DesignCR3BPSetup(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the CR3BP Setup Tool."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_secondary_body_name_method_offset = 3
    _set_secondary_body_name_method_offset = 4
    _get_initial_epoch_method_offset = 5
    _set_initial_epoch_method_offset = 6
    _get_ideal_orbit_radius_method_offset = 7
    _set_ideal_orbit_radius_method_offset = 8
    _get_ideal_secondary_name_method_offset = 9
    _set_ideal_secondary_name_method_offset = 10
    _get_mass_parameter_method_offset = 11
    _get_characteristic_distance_method_offset = 12
    _get_characteristic_time_method_offset = 13
    _get_characteristic_velocity_method_offset = 14
    _get_characteristic_acceleration_method_offset = 15
    _get_rotating_system_choice_method_offset = 16
    _set_rotating_system_choice_method_offset = 17
    _create_ideal_secondary_body_method_offset = 18
    _reset_ideal_secondary_body_method_offset = 19
    _update_ideal_secondary_cb_method_offset = 20
    _create_rotating_coordinate_system_method_offset = 21
    _delete_rotating_coordinate_system_method_offset = 22
    _create_calculation_objects_method_offset = 23
    _delete_calculation_objects_method_offset = 24
    _get_associated_objects_method_offset = 25
    _get_include_stm_method_offset = 26
    _set_include_stm_method_offset = 27
    _create_propagator_method_offset = 28
    _delete_propagator_method_offset = 29
    _metadata = {
        "iid_data" : (5264958649687951205, 13543844180411904148),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignCR3BPSetup)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Primary central body for the three-body system."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_central_body_name_metadata, value)

    _get_secondary_body_name_metadata = { "offset" : _get_secondary_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def secondary_body_name(self) -> str:
        """Secondary Body."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_secondary_body_name_metadata)

    _set_secondary_body_name_metadata = { "offset" : _set_secondary_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @secondary_body_name.setter
    def secondary_body_name(self, value:str) -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_secondary_body_name_metadata, value)

    _get_initial_epoch_metadata = { "offset" : _get_initial_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_epoch(self) -> typing.Any:
        """Date and time for system construction."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_initial_epoch_metadata)

    _set_initial_epoch_metadata = { "offset" : _set_initial_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @initial_epoch.setter
    def initial_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_initial_epoch_metadata, value)

    _get_ideal_orbit_radius_metadata = { "offset" : _get_ideal_orbit_radius_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IdealOrbitRadius),) }
    @property
    def ideal_orbit_radius(self) -> "IdealOrbitRadius":
        """Orbital radius of the idealized secondary definition."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_ideal_orbit_radius_metadata)

    _set_ideal_orbit_radius_metadata = { "offset" : _set_ideal_orbit_radius_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IdealOrbitRadius),) }
    @ideal_orbit_radius.setter
    def ideal_orbit_radius(self, value:"IdealOrbitRadius") -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_ideal_orbit_radius_metadata, value)

    _get_ideal_secondary_name_metadata = { "offset" : _get_ideal_secondary_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def ideal_secondary_name(self) -> str:
        """Name to be used for the idealized secondary."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_ideal_secondary_name_metadata)

    _set_ideal_secondary_name_metadata = { "offset" : _set_ideal_secondary_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @ideal_secondary_name.setter
    def ideal_secondary_name(self, value:str) -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_ideal_secondary_name_metadata, value)

    _get_mass_parameter_metadata = { "offset" : _get_mass_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_parameter(self) -> float:
        """Get the mass parameter computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_mass_parameter_metadata)

    _get_characteristic_distance_metadata = { "offset" : _get_characteristic_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_distance(self) -> float:
        """Get the characteristic distance computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_characteristic_distance_metadata)

    _get_characteristic_time_metadata = { "offset" : _get_characteristic_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_time(self) -> float:
        """Get the characteristic time computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_characteristic_time_metadata)

    _get_characteristic_velocity_metadata = { "offset" : _get_characteristic_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_velocity(self) -> float:
        """Get the characteristic velocity computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_characteristic_velocity_metadata)

    _get_characteristic_acceleration_metadata = { "offset" : _get_characteristic_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_acceleration(self) -> float:
        """Get the characteristic acceleration computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_characteristic_acceleration_metadata)

    _get_rotating_system_choice_metadata = { "offset" : _get_rotating_system_choice_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RotatingCoordinateSystem),) }
    @property
    def rotating_system_choice(self) -> "RotatingCoordinateSystem":
        """Get the rotating coordinate system and associated calculation objects to interact with."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_rotating_system_choice_metadata)

    _set_rotating_system_choice_metadata = { "offset" : _set_rotating_system_choice_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RotatingCoordinateSystem),) }
    @rotating_system_choice.setter
    def rotating_system_choice(self, value:"RotatingCoordinateSystem") -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_rotating_system_choice_metadata, value)

    _create_ideal_secondary_body_metadata = { "offset" : _create_ideal_secondary_body_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_ideal_secondary_body(self) -> None:
        """Construct the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._create_ideal_secondary_body_metadata, )

    _reset_ideal_secondary_body_metadata = { "offset" : _reset_ideal_secondary_body_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def reset_ideal_secondary_body(self) -> None:
        """Reset the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._reset_ideal_secondary_body_metadata, )

    _update_ideal_secondary_cb_metadata = { "offset" : _update_ideal_secondary_cb_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def update_ideal_secondary_cb(self) -> None:
        """Update the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._update_ideal_secondary_cb_metadata, )

    _create_rotating_coordinate_system_metadata = { "offset" : _create_rotating_coordinate_system_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_rotating_coordinate_system(self) -> None:
        """Create the coordinate system for the RotatingSystemChoice selection."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._create_rotating_coordinate_system_metadata, )

    _delete_rotating_coordinate_system_metadata = { "offset" : _delete_rotating_coordinate_system_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_rotating_coordinate_system(self) -> None:
        """Delete the coordinate system for the RotatingSystemChoice selection."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._delete_rotating_coordinate_system_metadata, )

    _create_calculation_objects_metadata = { "offset" : _create_calculation_objects_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_calculation_objects(self) -> None:
        """Create the calculation objects for the selected coordinate system."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._create_calculation_objects_metadata, )

    _delete_calculation_objects_metadata = { "offset" : _delete_calculation_objects_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_calculation_objects(self) -> None:
        """Delete the calculation objects for the selected coordinate system."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._delete_calculation_objects_metadata, )

    _get_associated_objects_metadata = { "offset" : _get_associated_objects_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def associated_objects(self) -> "DesignCR3BPObjectCollection":
        """Get the list of associated objects."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_associated_objects_metadata)

    _get_include_stm_metadata = { "offset" : _get_include_stm_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_stm(self) -> bool:
        """Get whether or not the STM propagator function is included on the propagator."""
        return self._intf.get_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._get_include_stm_metadata)

    _set_include_stm_metadata = { "offset" : _set_include_stm_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_stm.setter
    def include_stm(self, value:bool) -> None:
        return self._intf.set_property(DesignCR3BPSetup._metadata, DesignCR3BPSetup._set_include_stm_metadata, value)

    _create_propagator_metadata = { "offset" : _create_propagator_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_propagator(self) -> None:
        """Create the propagator for the primary-secondary CR3BP formulation."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._create_propagator_metadata, )

    _delete_propagator_metadata = { "offset" : _delete_propagator_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_propagator(self) -> None:
        """Delete the propagator for the primary-secondary CR3BP formulation."""
        return self._intf.invoke(DesignCR3BPSetup._metadata, DesignCR3BPSetup._delete_propagator_metadata, )

    _property_names[central_body_name] = "central_body_name"
    _property_names[secondary_body_name] = "secondary_body_name"
    _property_names[initial_epoch] = "initial_epoch"
    _property_names[ideal_orbit_radius] = "ideal_orbit_radius"
    _property_names[ideal_secondary_name] = "ideal_secondary_name"
    _property_names[mass_parameter] = "mass_parameter"
    _property_names[characteristic_distance] = "characteristic_distance"
    _property_names[characteristic_time] = "characteristic_time"
    _property_names[characteristic_velocity] = "characteristic_velocity"
    _property_names[characteristic_acceleration] = "characteristic_acceleration"
    _property_names[rotating_system_choice] = "rotating_system_choice"
    _property_names[associated_objects] = "associated_objects"
    _property_names[include_stm] = "include_stm"

    def __init__(self, source_object=None):
        """Construct an object of type DesignCR3BPSetup."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignCR3BPSetup)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignCR3BPSetup, [DesignCR3BPSetup, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5481838123027635983, 11793357896339033728), DesignCR3BPSetup)
agcls.AgTypeNameMap["DesignCR3BPSetup"] = DesignCR3BPSetup

class DesignCR3BPObject(SupportsDeleteCallback):
    """Properties for individual associated CR3BP object."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _get_object_type_method_offset = 2
    _get_object_depends_on_method_offset = 3
    _metadata = {
        "iid_data" : (5592045192875480542, 4785324167736681404),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignCR3BPObject)

    _get_object_name_metadata = { "offset" : _get_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_name(self) -> str:
        """Get the associated object name."""
        return self._intf.get_property(DesignCR3BPObject._metadata, DesignCR3BPObject._get_object_name_metadata)

    _get_object_type_metadata = { "offset" : _get_object_type_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_type(self) -> str:
        """Get the associated object type."""
        return self._intf.get_property(DesignCR3BPObject._metadata, DesignCR3BPObject._get_object_type_metadata)

    _get_object_depends_on_metadata = { "offset" : _get_object_depends_on_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_depends_on(self) -> str:
        """Get the associated object depends on."""
        return self._intf.get_property(DesignCR3BPObject._metadata, DesignCR3BPObject._get_object_depends_on_metadata)

    _property_names[object_name] = "object_name"
    _property_names[object_type] = "object_type"
    _property_names[object_depends_on] = "object_depends_on"

    def __init__(self, source_object=None):
        """Construct an object of type DesignCR3BPObject."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignCR3BPObject)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignCR3BPObject, [DesignCR3BPObject, ])

agcls.AgClassCatalog.add_catalog_entry((5056607814409438097, 3247415104540331914), DesignCR3BPObject)
agcls.AgTypeNameMap["DesignCR3BPObject"] = DesignCR3BPObject

class DesignCR3BPObjectCollection(SupportsDeleteCallback):
    """The list of associated CR3BP objects."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_item_by_index_method_offset = 4
    _get_item_by_name_method_offset = 5
    _metadata = {
        "iid_data" : (5392292082478645264, 18434852992809556111),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignCR3BPObjectCollection)
    def __iter__(self):
        """Create an iterator for the DesignCR3BPObjectCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "DesignCR3BPObject":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "DesignCR3BPObject":
        """Iterate through the collection."""
        return self._intf.invoke(DesignCR3BPObjectCollection._metadata, DesignCR3BPObjectCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """A property that allows you to enumerate through the collection."""
        return self._intf.get_property(DesignCR3BPObjectCollection._metadata, DesignCR3BPObjectCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Get the number of associated objects in the set."""
        return self._intf.get_property(DesignCR3BPObjectCollection._metadata, DesignCR3BPObjectCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "DesignCR3BPObject":
        """Retrieve an associated object from the collection by index."""
        return self._intf.invoke(DesignCR3BPObjectCollection._metadata, DesignCR3BPObjectCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "DesignCR3BPObject":
        """Retrieve an associated object from the collection by name."""
        return self._intf.invoke(DesignCR3BPObjectCollection._metadata, DesignCR3BPObjectCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type DesignCR3BPObjectCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignCR3BPObjectCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignCR3BPObjectCollection, [DesignCR3BPObjectCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4944643529672307384, 4598384306676136330), DesignCR3BPObjectCollection)
agcls.AgTypeNameMap["DesignCR3BPObjectCollection"] = DesignCR3BPObjectCollection

class DesignER3BPSetup(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for the ER3BP Setup Tool."""

    _num_methods = 30
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_secondary_body_name_method_offset = 3
    _set_secondary_body_name_method_offset = 4
    _get_initial_epoch_method_offset = 5
    _set_initial_epoch_method_offset = 6
    _get_true_anomaly_method_offset = 7
    _set_true_anomaly_method_offset = 8
    _get_ideal_secondary_name_method_offset = 9
    _set_ideal_secondary_name_method_offset = 10
    _get_mass_parameter_method_offset = 11
    _get_eccentricity_method_offset = 12
    _get_characteristic_distance_method_offset = 13
    _get_characteristic_time_method_offset = 14
    _get_characteristic_velocity_method_offset = 15
    _get_characteristic_acceleration_method_offset = 16
    _get_rotating_system_choice_method_offset = 17
    _set_rotating_system_choice_method_offset = 18
    _create_ideal_secondary_cb_method_offset = 19
    _reset_ideal_secondary_cb_method_offset = 20
    _update_ideal_secondary_cb_method_offset = 21
    _create_rotating_coordinate_system_method_offset = 22
    _delete_rotating_coordinate_system_method_offset = 23
    _create_calculation_objects_method_offset = 24
    _delete_calculation_objects_method_offset = 25
    _get_associated_objects_method_offset = 26
    _get_include_stm_method_offset = 27
    _set_include_stm_method_offset = 28
    _create_propagator_method_offset = 29
    _delete_propagator_method_offset = 30
    _metadata = {
        "iid_data" : (5065880826790351987, 2796329394240216450),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignER3BPSetup)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Primary central body for the three-body system."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_central_body_name_metadata, value)

    _get_secondary_body_name_metadata = { "offset" : _get_secondary_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def secondary_body_name(self) -> str:
        """Secondary Body."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_secondary_body_name_metadata)

    _set_secondary_body_name_metadata = { "offset" : _set_secondary_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @secondary_body_name.setter
    def secondary_body_name(self, value:str) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_secondary_body_name_metadata, value)

    _get_initial_epoch_metadata = { "offset" : _get_initial_epoch_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_epoch(self) -> typing.Any:
        """Date and time for system construction."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_initial_epoch_metadata)

    _set_initial_epoch_metadata = { "offset" : _set_initial_epoch_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @initial_epoch.setter
    def initial_epoch(self, value:typing.Any) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_initial_epoch_metadata, value)

    _get_true_anomaly_metadata = { "offset" : _get_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_anomaly(self) -> typing.Any:
        """True anomaly for initializing ideal secondary."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_true_anomaly_metadata)

    _set_true_anomaly_metadata = { "offset" : _set_true_anomaly_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_anomaly.setter
    def true_anomaly(self, value:typing.Any) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_true_anomaly_metadata, value)

    _get_ideal_secondary_name_metadata = { "offset" : _get_ideal_secondary_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def ideal_secondary_name(self) -> str:
        """Name to be used for the idealized secondary."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_ideal_secondary_name_metadata)

    _set_ideal_secondary_name_metadata = { "offset" : _set_ideal_secondary_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @ideal_secondary_name.setter
    def ideal_secondary_name(self, value:str) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_ideal_secondary_name_metadata, value)

    _get_mass_parameter_metadata = { "offset" : _get_mass_parameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass_parameter(self) -> float:
        """Get the mass parameter computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_mass_parameter_metadata)

    _get_eccentricity_metadata = { "offset" : _get_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eccentricity(self) -> float:
        """Get the eccentricity at epoch to be used for constructing the orbit of the secondary body."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_eccentricity_metadata)

    _get_characteristic_distance_metadata = { "offset" : _get_characteristic_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_distance(self) -> float:
        """Get the characteristic distance computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_characteristic_distance_metadata)

    _get_characteristic_time_metadata = { "offset" : _get_characteristic_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_time(self) -> float:
        """Get the characteristic time computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_characteristic_time_metadata)

    _get_characteristic_velocity_metadata = { "offset" : _get_characteristic_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_velocity(self) -> float:
        """Get the characteristic velocity computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_characteristic_velocity_metadata)

    _get_characteristic_acceleration_metadata = { "offset" : _get_characteristic_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def characteristic_acceleration(self) -> float:
        """Get the characteristic acceleration computed from the primary and secondary bodies."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_characteristic_acceleration_metadata)

    _get_rotating_system_choice_metadata = { "offset" : _get_rotating_system_choice_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RotatingCoordinateSystem),) }
    @property
    def rotating_system_choice(self) -> "RotatingCoordinateSystem":
        """Get the rotating coordinate system and associated calculation objects to interact with."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_rotating_system_choice_metadata)

    _set_rotating_system_choice_metadata = { "offset" : _set_rotating_system_choice_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RotatingCoordinateSystem),) }
    @rotating_system_choice.setter
    def rotating_system_choice(self, value:"RotatingCoordinateSystem") -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_rotating_system_choice_metadata, value)

    _create_ideal_secondary_cb_metadata = { "offset" : _create_ideal_secondary_cb_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_ideal_secondary_cb(self) -> None:
        """Construct the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._create_ideal_secondary_cb_metadata, )

    _reset_ideal_secondary_cb_metadata = { "offset" : _reset_ideal_secondary_cb_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def reset_ideal_secondary_cb(self) -> None:
        """Reset the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._reset_ideal_secondary_cb_metadata, )

    _update_ideal_secondary_cb_metadata = { "offset" : _update_ideal_secondary_cb_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def update_ideal_secondary_cb(self) -> None:
        """Update the idealized secondary for the three-body system."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._update_ideal_secondary_cb_metadata, )

    _create_rotating_coordinate_system_metadata = { "offset" : _create_rotating_coordinate_system_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_rotating_coordinate_system(self) -> None:
        """Create the coordinate system for the RotatingSystemChoice selection."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._create_rotating_coordinate_system_metadata, )

    _delete_rotating_coordinate_system_metadata = { "offset" : _delete_rotating_coordinate_system_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_rotating_coordinate_system(self) -> None:
        """Delete the coordinate system for the RotatingSystemChoice selection."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._delete_rotating_coordinate_system_metadata, )

    _create_calculation_objects_metadata = { "offset" : _create_calculation_objects_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_calculation_objects(self) -> None:
        """Create the calculation objects for the selected coordinate system."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._create_calculation_objects_metadata, )

    _delete_calculation_objects_metadata = { "offset" : _delete_calculation_objects_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_calculation_objects(self) -> None:
        """Delete the calculation objects for the selected coordinate system."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._delete_calculation_objects_metadata, )

    _get_associated_objects_metadata = { "offset" : _get_associated_objects_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def associated_objects(self) -> "DesignER3BPObjectCollection":
        """Get the list of associated objects."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_associated_objects_metadata)

    _get_include_stm_metadata = { "offset" : _get_include_stm_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def include_stm(self) -> bool:
        """Get whether or not the STM propagator function is included on the propagator."""
        return self._intf.get_property(DesignER3BPSetup._metadata, DesignER3BPSetup._get_include_stm_metadata)

    _set_include_stm_metadata = { "offset" : _set_include_stm_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @include_stm.setter
    def include_stm(self, value:bool) -> None:
        return self._intf.set_property(DesignER3BPSetup._metadata, DesignER3BPSetup._set_include_stm_metadata, value)

    _create_propagator_metadata = { "offset" : _create_propagator_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def create_propagator(self) -> None:
        """Create the propagator for the primary-secondary ER3BP formulation."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._create_propagator_metadata, )

    _delete_propagator_metadata = { "offset" : _delete_propagator_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete_propagator(self) -> None:
        """Delete the propagator for the primary-secondary ER3BP formulation."""
        return self._intf.invoke(DesignER3BPSetup._metadata, DesignER3BPSetup._delete_propagator_metadata, )

    _property_names[central_body_name] = "central_body_name"
    _property_names[secondary_body_name] = "secondary_body_name"
    _property_names[initial_epoch] = "initial_epoch"
    _property_names[true_anomaly] = "true_anomaly"
    _property_names[ideal_secondary_name] = "ideal_secondary_name"
    _property_names[mass_parameter] = "mass_parameter"
    _property_names[eccentricity] = "eccentricity"
    _property_names[characteristic_distance] = "characteristic_distance"
    _property_names[characteristic_time] = "characteristic_time"
    _property_names[characteristic_velocity] = "characteristic_velocity"
    _property_names[characteristic_acceleration] = "characteristic_acceleration"
    _property_names[rotating_system_choice] = "rotating_system_choice"
    _property_names[associated_objects] = "associated_objects"
    _property_names[include_stm] = "include_stm"

    def __init__(self, source_object=None):
        """Construct an object of type DesignER3BPSetup."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignER3BPSetup)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignER3BPSetup, [DesignER3BPSetup, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4729659118460925408, 15947058378431851408), DesignER3BPSetup)
agcls.AgTypeNameMap["DesignER3BPSetup"] = DesignER3BPSetup

class DesignER3BPObject(SupportsDeleteCallback):
    """Properties for individual associated ER3BP object."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _get_object_type_method_offset = 2
    _get_object_depends_on_method_offset = 3
    _metadata = {
        "iid_data" : (5302017474501657583, 7831999212900136352),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignER3BPObject)

    _get_object_name_metadata = { "offset" : _get_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_name(self) -> str:
        """Get the associated object name."""
        return self._intf.get_property(DesignER3BPObject._metadata, DesignER3BPObject._get_object_name_metadata)

    _get_object_type_metadata = { "offset" : _get_object_type_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_type(self) -> str:
        """Get the associated object type."""
        return self._intf.get_property(DesignER3BPObject._metadata, DesignER3BPObject._get_object_type_metadata)

    _get_object_depends_on_metadata = { "offset" : _get_object_depends_on_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_depends_on(self) -> str:
        """Get the associated object depends on."""
        return self._intf.get_property(DesignER3BPObject._metadata, DesignER3BPObject._get_object_depends_on_metadata)

    _property_names[object_name] = "object_name"
    _property_names[object_type] = "object_type"
    _property_names[object_depends_on] = "object_depends_on"

    def __init__(self, source_object=None):
        """Construct an object of type DesignER3BPObject."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignER3BPObject)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignER3BPObject, [DesignER3BPObject, ])

agcls.AgClassCatalog.add_catalog_entry((4634948133649418552, 5142846314822857399), DesignER3BPObject)
agcls.AgTypeNameMap["DesignER3BPObject"] = DesignER3BPObject

class DesignER3BPObjectCollection(SupportsDeleteCallback):
    """The list of associated ER3BP objects."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_item_by_index_method_offset = 4
    _get_item_by_name_method_offset = 5
    _metadata = {
        "iid_data" : (4950524500182993336, 7133458467934249351),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DesignER3BPObjectCollection)
    def __iter__(self):
        """Create an iterator for the DesignER3BPObjectCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "DesignER3BPObject":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "DesignER3BPObject":
        """Iterate through the collection."""
        return self._intf.invoke(DesignER3BPObjectCollection._metadata, DesignER3BPObjectCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """A property that allows you to enumerate through the collection."""
        return self._intf.get_property(DesignER3BPObjectCollection._metadata, DesignER3BPObjectCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Get the number of associated objects in the set."""
        return self._intf.get_property(DesignER3BPObjectCollection._metadata, DesignER3BPObjectCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "DesignER3BPObject":
        """Retrieve an associated object from the collection by index."""
        return self._intf.invoke(DesignER3BPObjectCollection._metadata, DesignER3BPObjectCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "DesignER3BPObject":
        """Retrieve an associated object from the collection by name."""
        return self._intf.invoke(DesignER3BPObjectCollection._metadata, DesignER3BPObjectCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type DesignER3BPObjectCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, DesignER3BPObjectCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DesignER3BPObjectCollection, [DesignER3BPObjectCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5559032907505982605, 14965528908650146187), DesignER3BPObjectCollection)
agcls.AgTypeNameMap["DesignER3BPObjectCollection"] = DesignER3BPObjectCollection

class Thruster(SupportsDeleteCallback):
    """Properties for individual thrusters."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_user_comment_method_offset = 3
    _set_user_comment_method_offset = 4
    _copy_method_offset = 5
    _get_engine_model_name_method_offset = 6
    _set_engine_model_name_method_offset = 7
    _get_thruster_efficiency_method_offset = 8
    _set_thruster_efficiency_method_offset = 9
    _get_equivalent_on_time_method_offset = 10
    _set_equivalent_on_time_method_offset = 11
    _get_thruster_direction_method_offset = 12
    _enable_control_parameter_method_offset = 13
    _disable_control_parameter_method_offset = 14
    _is_control_parameter_enabled_method_offset = 15
    _get_control_parameters_available_method_offset = 16
    _metadata = {
        "iid_data" : (5599776828859582129, 4144344513181628805),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Thruster)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get or set the thruster name."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        return self._intf.set_property(Thruster._metadata, Thruster._set_name_metadata, value)

    _get_user_comment_metadata = { "offset" : _get_user_comment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_comment(self) -> str:
        """A user comment."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_user_comment_metadata)

    _set_user_comment_metadata = { "offset" : _set_user_comment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_comment.setter
    def user_comment(self, value:str) -> None:
        return self._intf.set_property(Thruster._metadata, Thruster._set_user_comment_metadata, value)

    _copy_metadata = { "offset" : _copy_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def copy(self) -> "Thruster":
        """Make a copy of the specified thruster."""
        return self._intf.invoke(Thruster._metadata, Thruster._copy_metadata, OutArg())

    _get_engine_model_name_metadata = { "offset" : _get_engine_model_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def engine_model_name(self) -> str:
        """Get or set the engine model."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_engine_model_name_metadata)

    _set_engine_model_name_metadata = { "offset" : _set_engine_model_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @engine_model_name.setter
    def engine_model_name(self, value:str) -> None:
        return self._intf.set_property(Thruster._metadata, Thruster._set_engine_model_name_metadata, value)

    _get_thruster_efficiency_metadata = { "offset" : _get_thruster_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def thruster_efficiency(self) -> float:
        """Get or set the thruster efficiency. Dimensionless."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_thruster_efficiency_metadata)

    _set_thruster_efficiency_metadata = { "offset" : _set_thruster_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @thruster_efficiency.setter
    def thruster_efficiency(self, value:float) -> None:
        return self._intf.set_property(Thruster._metadata, Thruster._set_thruster_efficiency_metadata, value)

    _get_equivalent_on_time_metadata = { "offset" : _get_equivalent_on_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def equivalent_on_time(self) -> float:
        """Get or set the equivalent on-time percentage is a factor multiplied by the thrust. The thrust is applied continuously throughout the maneuver and is reduced by the percentage. The mass flow rate is likewise reduced. Dimensionless."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_equivalent_on_time_metadata)

    _set_equivalent_on_time_metadata = { "offset" : _set_equivalent_on_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @equivalent_on_time.setter
    def equivalent_on_time(self, value:float) -> None:
        return self._intf.set_property(Thruster._metadata, Thruster._set_equivalent_on_time_metadata, value)

    _get_thruster_direction_metadata = { "offset" : _get_thruster_direction_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def thruster_direction(self) -> "IDirection":
        """A thruster direction value."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_thruster_direction_metadata)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlThrusters),) }
    def enable_control_parameter(self, param:"ControlThrusters") -> None:
        """Enable the specified control parameter."""
        return self._intf.invoke(Thruster._metadata, Thruster._enable_control_parameter_metadata, param)

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ControlThrusters),) }
    def disable_control_parameter(self, param:"ControlThrusters") -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(Thruster._metadata, Thruster._disable_control_parameter_metadata, param)

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.EnumArg(ControlThrusters), agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self, param:"ControlThrusters") -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(Thruster._metadata, Thruster._is_control_parameter_enabled_metadata, param, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(Thruster._metadata, Thruster._get_control_parameters_available_metadata)

    _property_names[name] = "name"
    _property_names[user_comment] = "user_comment"
    _property_names[engine_model_name] = "engine_model_name"
    _property_names[thruster_efficiency] = "thruster_efficiency"
    _property_names[equivalent_on_time] = "equivalent_on_time"
    _property_names[thruster_direction] = "thruster_direction"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type Thruster."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Thruster)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, Thruster, [Thruster, ])

agcls.AgClassCatalog.add_catalog_entry((4928727831726254613, 15629250845104267194), Thruster)
agcls.AgTypeNameMap["Thruster"] = Thruster

class ThrusterSetCollection(SupportsDeleteCallback):
    """The list of thrusters in a thruster set."""

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _add_method_offset = 4
    _remove_method_offset = 5
    _remove_all_method_offset = 6
    _cut_method_offset = 7
    _paste_method_offset = 8
    _insert_copy_method_offset = 9
    _get_item_by_index_method_offset = 10
    _get_item_by_name_method_offset = 11
    _metadata = {
        "iid_data" : (5150845786246781308, 9319871362540407435),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ThrusterSetCollection)
    def __iter__(self):
        """Create an iterator for the ThrusterSetCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "Thruster":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "Thruster":
        """Iterate through the collection."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """A property that allows you to enumerate through the collection."""
        return self._intf.get_property(ThrusterSetCollection._metadata, ThrusterSetCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Get the number of thrusters in the set."""
        return self._intf.get_property(ThrusterSetCollection._metadata, ThrusterSetCollection._get_count_metadata)

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, thruster_name:str) -> "Thruster":
        """Add a new thruster."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._add_metadata, thruster_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a specified thruster."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all thrusters."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._remove_all_metadata, )

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy a thruster to the clipboard and removes the thruster from the list."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "Thruster":
        """Pastes a thruster from the clipboard into the list."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("Thruster"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, thruster:"Thruster") -> "Thruster":
        """Copy a thruster and inserts the copy into the list."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._insert_copy_metadata, thruster, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "Thruster":
        """Retrieve a thruster from the collection by index."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "Thruster":
        """Retrieve a thruster from the collection by name."""
        return self._intf.invoke(ThrusterSetCollection._metadata, ThrusterSetCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type ThrusterSetCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ThrusterSetCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ThrusterSetCollection, [ThrusterSetCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5241768383210010526, 2853913701615206820), ThrusterSetCollection)
agcls.AgTypeNameMap["ThrusterSetCollection"] = ThrusterSetCollection

class ThrusterSet(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """The properties of a thruster set."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_direction_definition_method_offset = 1
    _set_direction_definition_method_offset = 2
    _get_thrusters_method_offset = 3
    _metadata = {
        "iid_data" : (5226642763030458307, 9877909486177362105),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ThrusterSet)

    _get_direction_definition_metadata = { "offset" : _get_direction_definition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ThrusterDirection),) }
    @property
    def direction_definition(self) -> "ThrusterDirection":
        """Get or set the thruster set direction definition."""
        return self._intf.get_property(ThrusterSet._metadata, ThrusterSet._get_direction_definition_metadata)

    _set_direction_definition_metadata = { "offset" : _set_direction_definition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ThrusterDirection),) }
    @direction_definition.setter
    def direction_definition(self, value:"ThrusterDirection") -> None:
        return self._intf.set_property(ThrusterSet._metadata, ThrusterSet._set_direction_definition_metadata, value)

    _get_thrusters_metadata = { "offset" : _get_thrusters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def thrusters(self) -> "ThrusterSetCollection":
        """Get the list of thrusters."""
        return self._intf.get_property(ThrusterSet._metadata, ThrusterSet._get_thrusters_metadata)

    _property_names[direction_definition] = "direction_definition"
    _property_names[thrusters] = "thrusters"

    def __init__(self, source_object=None):
        """Construct an object of type ThrusterSet."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ThrusterSet)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ThrusterSet, [ThrusterSet, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((4871586803196060100, 17136152086637392032), ThrusterSet)
agcls.AgTypeNameMap["ThrusterSet"] = ThrusterSet

class AsTriggerCondition(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for a constraint - an additional condition to be met to satisfy a stopping condition."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_criteria_method_offset = 1
    _set_criteria_method_offset = 2
    _get_calculation_object_method_offset = 3
    _set_calculation_object_method_offset = 4
    _get_calculation_object_name_method_offset = 5
    _set_calculation_object_name_method_offset = 6
    _get_value_method_offset = 7
    _set_value_method_offset = 8
    _get_tolerance_method_offset = 9
    _set_tolerance_method_offset = 10
    _get_use_absolute_value_method_offset = 11
    _set_use_absolute_value_method_offset = 12
    _copy_calculation_object_to_clipboard_method_offset = 13
    _paste_calculation_object_from_clipboard_method_offset = 14
    _metadata = {
        "iid_data" : (4822555187395734580, 16648748127025965747),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AsTriggerCondition)

    _get_criteria_metadata = { "offset" : _get_criteria_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Criteria),) }
    @property
    def criteria(self) -> "Criteria":
        """Get or set the criteria to be applied to the desired value."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_criteria_metadata)

    _set_criteria_metadata = { "offset" : _set_criteria_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Criteria),) }
    @criteria.setter
    def criteria(self, value:"Criteria") -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_criteria_metadata, value)

    _get_calculation_object_metadata = { "offset" : _get_calculation_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_object(self) -> "IComponentInfo":
        """Get or set the calculation object to perform calculation to evaluate condition."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_calculation_object_metadata)

    _set_calculation_object_metadata = { "offset" : _set_calculation_object_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"),) }
    @calculation_object.setter
    def calculation_object(self, value:"IComponentInfo") -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_calculation_object_metadata, value)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the name of the calculation object to perform calculation to evaluate condition."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_calculation_object_name_metadata, value)

    _get_value_metadata = { "offset" : _get_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def value(self) -> typing.Any:
        """Get or set the value to satisfy the condition. Dimension depends on CalcObject."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_value_metadata)

    _set_value_metadata = { "offset" : _set_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @value.setter
    def value(self, value:typing.Any) -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_value_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tolerance(self) -> typing.Any:
        """How closely the test parameter must approximate the desired value for the constraint. Dimension depends on CalcObject."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tolerance.setter
    def tolerance(self, value:typing.Any) -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_tolerance_metadata, value)

    _get_use_absolute_value_metadata = { "offset" : _get_use_absolute_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_absolute_value(self) -> bool:
        """Whether or not to take the absolute value of the calculation."""
        return self._intf.get_property(AsTriggerCondition._metadata, AsTriggerCondition._get_use_absolute_value_metadata)

    _set_use_absolute_value_metadata = { "offset" : _set_use_absolute_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_absolute_value.setter
    def use_absolute_value(self, value:bool) -> None:
        return self._intf.set_property(AsTriggerCondition._metadata, AsTriggerCondition._set_use_absolute_value_metadata, value)

    _copy_calculation_object_to_clipboard_metadata = { "offset" : _copy_calculation_object_to_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_calculation_object_to_clipboard(self) -> None:
        """Copy calculation object to clipboard."""
        return self._intf.invoke(AsTriggerCondition._metadata, AsTriggerCondition._copy_calculation_object_to_clipboard_metadata, )

    _paste_calculation_object_from_clipboard_metadata = { "offset" : _paste_calculation_object_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_calculation_object_from_clipboard(self) -> None:
        """Replace calculation object with instance in clipboard."""
        return self._intf.invoke(AsTriggerCondition._metadata, AsTriggerCondition._paste_calculation_object_from_clipboard_metadata, )

    _property_names[criteria] = "criteria"
    _property_names[calculation_object] = "calculation_object"
    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[value] = "value"
    _property_names[tolerance] = "tolerance"
    _property_names[use_absolute_value] = "use_absolute_value"

    def __init__(self, source_object=None):
        """Construct an object of type AsTriggerCondition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AsTriggerCondition)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, AsTriggerCondition, [AsTriggerCondition, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5463923426204927664, 16539300349541669282), AsTriggerCondition)
agcls.AgTypeNameMap["AsTriggerCondition"] = AsTriggerCondition

class CustomFunctionScriptEngine(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """Properties for custom functions."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_script_filename_method_offset = 1
    _set_script_filename_method_offset = 2
    _get_file_extension_name_method_offset = 3
    _set_file_extension_name_method_offset = 4
    _metadata = {
        "iid_data" : (4615251189220139708, 578580787211182211),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CustomFunctionScriptEngine)

    _get_script_filename_metadata = { "offset" : _get_script_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def script_filename(self) -> str:
        """Get or set the file containing the function to call."""
        return self._intf.get_property(CustomFunctionScriptEngine._metadata, CustomFunctionScriptEngine._get_script_filename_metadata)

    _set_script_filename_metadata = { "offset" : _set_script_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @script_filename.setter
    def script_filename(self, value:str) -> None:
        return self._intf.set_property(CustomFunctionScriptEngine._metadata, CustomFunctionScriptEngine._set_script_filename_metadata, value)

    _get_file_extension_name_metadata = { "offset" : _get_file_extension_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def file_extension_name(self) -> str:
        """Get or set the file extension."""
        return self._intf.get_property(CustomFunctionScriptEngine._metadata, CustomFunctionScriptEngine._get_file_extension_name_metadata)

    _set_file_extension_name_metadata = { "offset" : _set_file_extension_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @file_extension_name.setter
    def file_extension_name(self, value:str) -> None:
        return self._intf.set_property(CustomFunctionScriptEngine._metadata, CustomFunctionScriptEngine._set_file_extension_name_metadata, value)

    _property_names[script_filename] = "script_filename"
    _property_names[file_extension_name] = "file_extension_name"

    def __init__(self, source_object=None):
        """Construct an object of type CustomFunctionScriptEngine."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CustomFunctionScriptEngine)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CustomFunctionScriptEngine, [CustomFunctionScriptEngine, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5687711712574011852, 8387513872181828256), CustomFunctionScriptEngine)
agcls.AgTypeNameMap["CustomFunctionScriptEngine"] = CustomFunctionScriptEngine

class NumericalPropagatorWrapper(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """General properties for propagators."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_use_variation_of_parameters_method_offset = 3
    _set_use_variation_of_parameters_method_offset = 4
    _get_use_regularized_time_method_offset = 5
    _set_use_regularized_time_method_offset = 6
    _get_regularized_time_exponent_method_offset = 7
    _set_regularized_time_exponent_method_offset = 8
    _get_regularized_time_steps_per_orbit_method_offset = 9
    _set_regularized_time_steps_per_orbit_method_offset = 10
    _get_propagator_functions_method_offset = 11
    _get_numerical_integrator_method_offset = 12
    _get_numerical_integrator_type_method_offset = 13
    _set_numerical_integrator_method_offset = 14
    _metadata = {
        "iid_data" : (5516706745347836377, 14251979156411537064),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, NumericalPropagatorWrapper)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body for Propagation."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_central_body_name_metadata, value)

    _get_use_variation_of_parameters_metadata = { "offset" : _get_use_variation_of_parameters_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_variation_of_parameters(self) -> bool:
        """Whether or not to use a variation of parameters(VOP) in universal variables formulation of the equations of motion; related to numerical integrator."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_use_variation_of_parameters_metadata)

    _set_use_variation_of_parameters_metadata = { "offset" : _set_use_variation_of_parameters_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_variation_of_parameters.setter
    def use_variation_of_parameters(self, value:bool) -> None:
        return self._intf.set_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_use_variation_of_parameters_metadata, value)

    _get_use_regularized_time_metadata = { "offset" : _get_use_regularized_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_regularized_time(self) -> bool:
        """Whether or not to use regularized time; related to numerical integrator."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_use_regularized_time_metadata)

    _set_use_regularized_time_metadata = { "offset" : _set_use_regularized_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_regularized_time.setter
    def use_regularized_time(self, value:bool) -> None:
        return self._intf.set_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_use_regularized_time_metadata, value)

    _get_regularized_time_exponent_metadata = { "offset" : _get_regularized_time_exponent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def regularized_time_exponent(self) -> float:
        """Get or set the exponent to use in regularized time; related to numerical integrator. Dimensionless."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_regularized_time_exponent_metadata)

    _set_regularized_time_exponent_metadata = { "offset" : _set_regularized_time_exponent_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @regularized_time_exponent.setter
    def regularized_time_exponent(self, value:float) -> None:
        return self._intf.set_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_regularized_time_exponent_metadata, value)

    _get_regularized_time_steps_per_orbit_metadata = { "offset" : _get_regularized_time_steps_per_orbit_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def regularized_time_steps_per_orbit(self) -> int:
        """Get or set the steps per orbit used in regularized time; related to numerical integrator. Dimensionless."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_regularized_time_steps_per_orbit_metadata)

    _set_regularized_time_steps_per_orbit_metadata = { "offset" : _set_regularized_time_steps_per_orbit_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @regularized_time_steps_per_orbit.setter
    def regularized_time_steps_per_orbit(self, value:int) -> None:
        return self._intf.set_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_regularized_time_steps_per_orbit_metadata, value)

    _get_propagator_functions_metadata = { "offset" : _get_propagator_functions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propagator_functions(self) -> "PropagatorFunctionCollection":
        """Get the list of propagator functions."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_propagator_functions_metadata)

    _get_numerical_integrator_metadata = { "offset" : _get_numerical_integrator_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def numerical_integrator(self) -> "INumericalIntegrator":
        """Get the numerical integrator."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_numerical_integrator_metadata)

    _get_numerical_integrator_type_metadata = { "offset" : _get_numerical_integrator_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    @property
    def numerical_integrator_type(self) -> "NumericalIntegrator":
        """Get the single step integrator type."""
        return self._intf.get_property(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._get_numerical_integrator_type_metadata)

    _set_numerical_integrator_metadata = { "offset" : _set_numerical_integrator_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    def set_numerical_integrator(self, integrator:"NumericalIntegrator") -> None:
        """Change the single step integrator."""
        return self._intf.invoke(NumericalPropagatorWrapper._metadata, NumericalPropagatorWrapper._set_numerical_integrator_metadata, integrator)

    _property_names[central_body_name] = "central_body_name"
    _property_names[use_variation_of_parameters] = "use_variation_of_parameters"
    _property_names[use_regularized_time] = "use_regularized_time"
    _property_names[regularized_time_exponent] = "regularized_time_exponent"
    _property_names[regularized_time_steps_per_orbit] = "regularized_time_steps_per_orbit"
    _property_names[propagator_functions] = "propagator_functions"
    _property_names[numerical_integrator] = "numerical_integrator"
    _property_names[numerical_integrator_type] = "numerical_integrator_type"

    def __init__(self, source_object=None):
        """Construct an object of type NumericalPropagatorWrapper."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, NumericalPropagatorWrapper)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, NumericalPropagatorWrapper, [NumericalPropagatorWrapper, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5585542860795755319, 14715416518501616516), NumericalPropagatorWrapper)
agcls.AgTypeNameMap["NumericalPropagatorWrapper"] = NumericalPropagatorWrapper

class NumericalPropagatorWrapperCR3BP(IComponentInfo, ICloneable, SupportsDeleteCallback):
    """General properties for three-body problem propagators."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_central_body_name_method_offset = 1
    _set_central_body_name_method_offset = 2
    _get_propagator_functions_method_offset = 3
    _get_numerical_integrator_method_offset = 4
    _get_numerical_integrator_type_method_offset = 5
    _set_numerical_integrator_method_offset = 6
    _metadata = {
        "iid_data" : (4855858447190994553, 6591909352563703225),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, NumericalPropagatorWrapperCR3BP)

    _get_central_body_name_metadata = { "offset" : _get_central_body_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def central_body_name(self) -> str:
        """Get or set the central body for Propagation."""
        return self._intf.get_property(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._get_central_body_name_metadata)

    _set_central_body_name_metadata = { "offset" : _set_central_body_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @central_body_name.setter
    def central_body_name(self, value:str) -> None:
        return self._intf.set_property(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._set_central_body_name_metadata, value)

    _get_propagator_functions_metadata = { "offset" : _get_propagator_functions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propagator_functions(self) -> "PropagatorFunctionCollection":
        """Get the list of propagator functions."""
        return self._intf.get_property(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._get_propagator_functions_metadata)

    _get_numerical_integrator_metadata = { "offset" : _get_numerical_integrator_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def numerical_integrator(self) -> "INumericalIntegrator":
        """Get the numerical integrator."""
        return self._intf.get_property(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._get_numerical_integrator_metadata)

    _get_numerical_integrator_type_metadata = { "offset" : _get_numerical_integrator_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    @property
    def numerical_integrator_type(self) -> "NumericalIntegrator":
        """Get the numerical integrator type."""
        return self._intf.get_property(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._get_numerical_integrator_type_metadata)

    _set_numerical_integrator_metadata = { "offset" : _set_numerical_integrator_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    def set_numerical_integrator(self, integrator:"NumericalIntegrator") -> None:
        """Change the numerical integrator."""
        return self._intf.invoke(NumericalPropagatorWrapperCR3BP._metadata, NumericalPropagatorWrapperCR3BP._set_numerical_integrator_metadata, integrator)

    _property_names[central_body_name] = "central_body_name"
    _property_names[propagator_functions] = "propagator_functions"
    _property_names[numerical_integrator] = "numerical_integrator"
    _property_names[numerical_integrator_type] = "numerical_integrator_type"

    def __init__(self, source_object=None):
        """Construct an object of type NumericalPropagatorWrapperCR3BP."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, NumericalPropagatorWrapperCR3BP)
        IComponentInfo.__init__(self, source_object)
        ICloneable.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IComponentInfo._private_init(self, intf)
        ICloneable._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, NumericalPropagatorWrapperCR3BP, [NumericalPropagatorWrapperCR3BP, IComponentInfo, ICloneable])

agcls.AgClassCatalog.add_catalog_entry((5175736139608374254, 18343359665990805900), NumericalPropagatorWrapperCR3BP)
agcls.AgTypeNameMap["NumericalPropagatorWrapperCR3BP"] = NumericalPropagatorWrapperCR3BP

class PropagatorFunctionCollection(SupportsDeleteCallback):
    """The list of propagator functions - affecting forces that you want to model for orbit propagation."""

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _item_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _remove_all_method_offset = 6
    _cut_method_offset = 7
    _paste_method_offset = 8
    _insert_copy_method_offset = 9
    _get_item_by_index_method_offset = 10
    _get_item_by_name_method_offset = 11
    _metadata = {
        "iid_data" : (5526427479745593523, 16580441229047482540),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PropagatorFunctionCollection)
    def __iter__(self):
        """Create an iterator for the PropagatorFunctionCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IComponentInfo":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, result_name:str) -> "IComponentInfo":
        """Add a function to the collection."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._add_metadata, result_name, OutArg())

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "IComponentInfo":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._item_metadata, index_or_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove the specified function from the collection."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._get_count_metadata)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all functions from the collection."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._remove_all_metadata, )

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy a propagator function to the clipboard and removes the propagator function from the list."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "IComponentInfo":
        """Pastes a propagator function from the clipboard into the list."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, prop_func:"IComponentInfo") -> "IComponentInfo":
        """Copy a propagator function and inserts the copy into the list."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._insert_copy_metadata, prop_func, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "IComponentInfo":
        """Retrieve a propagator function from the collection by index."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "IComponentInfo":
        """Retrieve a propagator function from the collection by name."""
        return self._intf.invoke(PropagatorFunctionCollection._metadata, PropagatorFunctionCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type PropagatorFunctionCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PropagatorFunctionCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PropagatorFunctionCollection, [PropagatorFunctionCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4733298211782133858, 8850809927363953818), PropagatorFunctionCollection)
agcls.AgTypeNameMap["PropagatorFunctionCollection"] = PropagatorFunctionCollection

class BulirschStoerIntegrator(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the Bulirsch-Stoer numerical integrator."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_sequences_method_offset = 15
    _set_max_sequences_method_offset = 16
    _get_max_iterations_method_offset = 17
    _set_max_iterations_method_offset = 18
    _get_tolerance_method_offset = 19
    _set_tolerance_method_offset = 20
    _get_first_safety_coefficient_method_offset = 21
    _set_first_safety_coefficient_method_offset = 22
    _get_second_safety_coefficient_method_offset = 23
    _set_second_safety_coefficient_method_offset = 24
    _metadata = {
        "iid_data" : (4637303974342457954, 933667345742664628),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BulirschStoerIntegrator)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_max_relative_err_metadata, value)

    _get_max_sequences_metadata = { "offset" : _get_max_sequences_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_sequences(self) -> int:
        """Get or set the maximum number of sequences. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_max_sequences_metadata)

    _set_max_sequences_metadata = { "offset" : _set_max_sequences_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_sequences.setter
    def max_sequences(self, value:int) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_max_sequences_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum number of iterations. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_max_iterations_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance(self) -> float:
        """Get or set the error tolerance for step size control. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance.setter
    def tolerance(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_tolerance_metadata, value)

    _get_first_safety_coefficient_metadata = { "offset" : _get_first_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def first_safety_coefficient(self) -> float:
        """Get or set the first safety coefficient. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_first_safety_coefficient_metadata)

    _set_first_safety_coefficient_metadata = { "offset" : _set_first_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @first_safety_coefficient.setter
    def first_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_first_safety_coefficient_metadata, value)

    _get_second_safety_coefficient_metadata = { "offset" : _get_second_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def second_safety_coefficient(self) -> float:
        """Get or set the second safety coefficient. Dimensionless."""
        return self._intf.get_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._get_second_safety_coefficient_metadata)

    _set_second_safety_coefficient_metadata = { "offset" : _set_second_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @second_safety_coefficient.setter
    def second_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(BulirschStoerIntegrator._metadata, BulirschStoerIntegrator._set_second_safety_coefficient_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_sequences] = "max_sequences"
    _property_names[max_iterations] = "max_iterations"
    _property_names[tolerance] = "tolerance"
    _property_names[first_safety_coefficient] = "first_safety_coefficient"
    _property_names[second_safety_coefficient] = "second_safety_coefficient"

    def __init__(self, source_object=None):
        """Construct an object of type BulirschStoerIntegrator."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BulirschStoerIntegrator)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BulirschStoerIntegrator, [BulirschStoerIntegrator, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((4731955954915235525, 1753081381555895174), BulirschStoerIntegrator)
agcls.AgTypeNameMap["BulirschStoerIntegrator"] = BulirschStoerIntegrator

class GaussJacksonIntegrator(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the Gauss-Jackson numerical integrator."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_max_corrector_relative_err_method_offset = 3
    _set_max_corrector_relative_err_method_offset = 4
    _get_corrector_mode_method_offset = 5
    _set_corrector_mode_method_offset = 6
    _get_max_corrector_iterations_method_offset = 7
    _set_max_corrector_iterations_method_offset = 8
    _get_single_step_integrator_method_offset = 9
    _get_single_step_integrator_type_method_offset = 10
    _set_single_step_integrator_method_offset = 11
    _metadata = {
        "iid_data" : (5739514811298770911, 891298140076643235),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GaussJacksonIntegrator)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._set_initial_step_metadata, value)

    _get_max_corrector_relative_err_metadata = { "offset" : _get_max_corrector_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_corrector_relative_err(self) -> float:
        """Get or set the maximum relative error between corrector iterations. Dimensionless."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_max_corrector_relative_err_metadata)

    _set_max_corrector_relative_err_metadata = { "offset" : _set_max_corrector_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_corrector_relative_err.setter
    def max_corrector_relative_err(self, value:float) -> None:
        return self._intf.set_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._set_max_corrector_relative_err_metadata, value)

    _get_corrector_mode_metadata = { "offset" : _get_corrector_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PredictorCorrector),) }
    @property
    def corrector_mode(self) -> "PredictorCorrector":
        """Get or set the Predictor Corrector scheme."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_corrector_mode_metadata)

    _set_corrector_mode_metadata = { "offset" : _set_corrector_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PredictorCorrector),) }
    @corrector_mode.setter
    def corrector_mode(self, value:"PredictorCorrector") -> None:
        return self._intf.set_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._set_corrector_mode_metadata, value)

    _get_max_corrector_iterations_metadata = { "offset" : _get_max_corrector_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_corrector_iterations(self) -> int:
        """Get or set the maximum corrector iterations. Dimensionless."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_max_corrector_iterations_metadata)

    _set_max_corrector_iterations_metadata = { "offset" : _set_max_corrector_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_corrector_iterations.setter
    def max_corrector_iterations(self, value:int) -> None:
        return self._intf.set_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._set_max_corrector_iterations_metadata, value)

    _get_single_step_integrator_metadata = { "offset" : _get_single_step_integrator_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def single_step_integrator(self) -> "INumericalIntegrator":
        """Get the stopping integrator; a single-step integrator."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_single_step_integrator_metadata)

    _get_single_step_integrator_type_metadata = { "offset" : _get_single_step_integrator_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    @property
    def single_step_integrator_type(self) -> "NumericalIntegrator":
        """Get the stopping integrator type."""
        return self._intf.get_property(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._get_single_step_integrator_type_metadata)

    _set_single_step_integrator_metadata = { "offset" : _set_single_step_integrator_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NumericalIntegrator),) }
    def set_single_step_integrator(self, integrator:"NumericalIntegrator") -> None:
        """Change the stopping integrator."""
        return self._intf.invoke(GaussJacksonIntegrator._metadata, GaussJacksonIntegrator._set_single_step_integrator_metadata, integrator)

    _property_names[initial_step] = "initial_step"
    _property_names[max_corrector_relative_err] = "max_corrector_relative_err"
    _property_names[corrector_mode] = "corrector_mode"
    _property_names[max_corrector_iterations] = "max_corrector_iterations"
    _property_names[single_step_integrator] = "single_step_integrator"
    _property_names[single_step_integrator_type] = "single_step_integrator_type"

    def __init__(self, source_object=None):
        """Construct an object of type GaussJacksonIntegrator."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GaussJacksonIntegrator)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GaussJacksonIntegrator, [GaussJacksonIntegrator, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((5486032430987957740, 15684774974462300568), GaussJacksonIntegrator)
agcls.AgTypeNameMap["GaussJacksonIntegrator"] = GaussJacksonIntegrator

class RungeKutta2nd3rd(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK2nd3rd numerical integrator."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_absolute_err_method_offset = 15
    _set_max_absolute_err_method_offset = 16
    _get_high_safety_coefficient_method_offset = 17
    _set_high_safety_coefficient_method_offset = 18
    _get_low_safety_coefficient_method_offset = 19
    _set_low_safety_coefficient_method_offset = 20
    _get_error_control_method_offset = 21
    _set_error_control_method_offset = 22
    _get_max_iterations_method_offset = 23
    _set_max_iterations_method_offset = 24
    _metadata = {
        "iid_data" : (5029371599579144861, 8833459632619542423),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKutta2nd3rd)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_max_relative_err_metadata, value)

    _get_max_absolute_err_metadata = { "offset" : _get_max_absolute_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_err(self) -> float:
        """Get or set the maximum absolute error; Also used if relative scale is too small. Dimensionless."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_max_absolute_err_metadata)

    _set_max_absolute_err_metadata = { "offset" : _set_max_absolute_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_absolute_err.setter
    def max_absolute_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_max_absolute_err_metadata, value)

    _get_high_safety_coefficient_metadata = { "offset" : _get_high_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def high_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to decrease step size if the error is too high. Dimensionless."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_high_safety_coefficient_metadata)

    _set_high_safety_coefficient_metadata = { "offset" : _set_high_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @high_safety_coefficient.setter
    def high_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_high_safety_coefficient_metadata, value)

    _get_low_safety_coefficient_metadata = { "offset" : _get_low_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def low_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to increase step size if the error is too low. Dimensionless."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_low_safety_coefficient_metadata)

    _set_low_safety_coefficient_metadata = { "offset" : _set_low_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @low_safety_coefficient.setter
    def low_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_low_safety_coefficient_metadata, value)

    _get_error_control_metadata = { "offset" : _get_error_control_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @property
    def error_control(self) -> "ErrorControl":
        """Get or set the error control method."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_error_control_metadata)

    _set_error_control_metadata = { "offset" : _set_error_control_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @error_control.setter
    def error_control(self, value:"ErrorControl") -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_error_control_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum iterations. Dimensionless."""
        return self._intf.get_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(RungeKutta2nd3rd._metadata, RungeKutta2nd3rd._set_max_iterations_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_absolute_err] = "max_absolute_err"
    _property_names[high_safety_coefficient] = "high_safety_coefficient"
    _property_names[low_safety_coefficient] = "low_safety_coefficient"
    _property_names[error_control] = "error_control"
    _property_names[max_iterations] = "max_iterations"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKutta2nd3rd."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKutta2nd3rd)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKutta2nd3rd, [RungeKutta2nd3rd, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((5013268286479080464, 11193883274659343489), RungeKutta2nd3rd)
agcls.AgTypeNameMap["RungeKutta2nd3rd"] = RungeKutta2nd3rd

class RungeKutta4th(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK4th numerical integrator."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _metadata = {
        "iid_data" : (5335025532636155549, 11281214721828458654),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKutta4th)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKutta4th._metadata, RungeKutta4th._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th._metadata, RungeKutta4th._set_initial_step_metadata, value)

    _property_names[initial_step] = "initial_step"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKutta4th."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKutta4th)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKutta4th, [RungeKutta4th, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((4823736396468222347, 4720771055494135428), RungeKutta4th)
agcls.AgTypeNameMap["RungeKutta4th"] = RungeKutta4th

class RungeKutta4th5th(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK4th5th numerical integrator."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_absolute_err_method_offset = 15
    _set_max_absolute_err_method_offset = 16
    _get_high_safety_coefficient_method_offset = 17
    _set_high_safety_coefficient_method_offset = 18
    _get_low_safety_coefficient_method_offset = 19
    _set_low_safety_coefficient_method_offset = 20
    _get_error_control_method_offset = 21
    _set_error_control_method_offset = 22
    _get_max_iterations_method_offset = 23
    _set_max_iterations_method_offset = 24
    _metadata = {
        "iid_data" : (5450222780175851139, 4668614171350112699),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKutta4th5th)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_max_relative_err_metadata, value)

    _get_max_absolute_err_metadata = { "offset" : _get_max_absolute_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_err(self) -> float:
        """Get or set the maximum absolute error; Also used if relative scale is too small. Dimensionless."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_max_absolute_err_metadata)

    _set_max_absolute_err_metadata = { "offset" : _set_max_absolute_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_absolute_err.setter
    def max_absolute_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_max_absolute_err_metadata, value)

    _get_high_safety_coefficient_metadata = { "offset" : _get_high_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def high_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to decrease step size if the error is too high. Dimensionless."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_high_safety_coefficient_metadata)

    _set_high_safety_coefficient_metadata = { "offset" : _set_high_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @high_safety_coefficient.setter
    def high_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_high_safety_coefficient_metadata, value)

    _get_low_safety_coefficient_metadata = { "offset" : _get_low_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def low_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to increase step size if the error is too low. Dimensionless."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_low_safety_coefficient_metadata)

    _set_low_safety_coefficient_metadata = { "offset" : _set_low_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @low_safety_coefficient.setter
    def low_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_low_safety_coefficient_metadata, value)

    _get_error_control_metadata = { "offset" : _get_error_control_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @property
    def error_control(self) -> "ErrorControl":
        """Get or set the error control method."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_error_control_metadata)

    _set_error_control_metadata = { "offset" : _set_error_control_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @error_control.setter
    def error_control(self, value:"ErrorControl") -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_error_control_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum iterations. Dimensionless."""
        return self._intf.get_property(RungeKutta4th5th._metadata, RungeKutta4th5th._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(RungeKutta4th5th._metadata, RungeKutta4th5th._set_max_iterations_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_absolute_err] = "max_absolute_err"
    _property_names[high_safety_coefficient] = "high_safety_coefficient"
    _property_names[low_safety_coefficient] = "low_safety_coefficient"
    _property_names[error_control] = "error_control"
    _property_names[max_iterations] = "max_iterations"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKutta4th5th."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKutta4th5th)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKutta4th5th, [RungeKutta4th5th, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((5037275303378310013, 15369839879042503843), RungeKutta4th5th)
agcls.AgTypeNameMap["RungeKutta4th5th"] = RungeKutta4th5th

class RungeKutta4thAdapt(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK4thAdapt numerical integrator."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_absolute_err_method_offset = 15
    _set_max_absolute_err_method_offset = 16
    _get_high_safety_coefficient_method_offset = 17
    _set_high_safety_coefficient_method_offset = 18
    _get_low_safety_coefficient_method_offset = 19
    _set_low_safety_coefficient_method_offset = 20
    _get_error_control_method_offset = 21
    _set_error_control_method_offset = 22
    _get_max_iterations_method_offset = 23
    _set_max_iterations_method_offset = 24
    _metadata = {
        "iid_data" : (5274574660423565325, 9613513386779582873),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKutta4thAdapt)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_max_relative_err_metadata, value)

    _get_max_absolute_err_metadata = { "offset" : _get_max_absolute_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_err(self) -> float:
        """Get or set the maximum absolute error; Also used if relative scale is too small. Dimensionless."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_max_absolute_err_metadata)

    _set_max_absolute_err_metadata = { "offset" : _set_max_absolute_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_absolute_err.setter
    def max_absolute_err(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_max_absolute_err_metadata, value)

    _get_high_safety_coefficient_metadata = { "offset" : _get_high_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def high_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to decrease step size if the error is too high. Dimensionless."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_high_safety_coefficient_metadata)

    _set_high_safety_coefficient_metadata = { "offset" : _set_high_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @high_safety_coefficient.setter
    def high_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_high_safety_coefficient_metadata, value)

    _get_low_safety_coefficient_metadata = { "offset" : _get_low_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def low_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to increase step size if the error is too low. Dimensionless."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_low_safety_coefficient_metadata)

    _set_low_safety_coefficient_metadata = { "offset" : _set_low_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @low_safety_coefficient.setter
    def low_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_low_safety_coefficient_metadata, value)

    _get_error_control_metadata = { "offset" : _get_error_control_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @property
    def error_control(self) -> "ErrorControl":
        """Get or set the error control method."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_error_control_metadata)

    _set_error_control_metadata = { "offset" : _set_error_control_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @error_control.setter
    def error_control(self, value:"ErrorControl") -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_error_control_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum iterations. Dimensionless."""
        return self._intf.get_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(RungeKutta4thAdapt._metadata, RungeKutta4thAdapt._set_max_iterations_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_absolute_err] = "max_absolute_err"
    _property_names[high_safety_coefficient] = "high_safety_coefficient"
    _property_names[low_safety_coefficient] = "low_safety_coefficient"
    _property_names[error_control] = "error_control"
    _property_names[max_iterations] = "max_iterations"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKutta4thAdapt."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKutta4thAdapt)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKutta4thAdapt, [RungeKutta4thAdapt, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((4758480604737476882, 4943826813823350154), RungeKutta4thAdapt)
agcls.AgTypeNameMap["RungeKutta4thAdapt"] = RungeKutta4thAdapt

class RungeKuttaF7th8th(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK7th8th numerical integrator."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_absolute_err_method_offset = 15
    _set_max_absolute_err_method_offset = 16
    _get_high_safety_coefficient_method_offset = 17
    _set_high_safety_coefficient_method_offset = 18
    _get_low_safety_coefficient_method_offset = 19
    _set_low_safety_coefficient_method_offset = 20
    _get_error_control_method_offset = 21
    _set_error_control_method_offset = 22
    _get_max_iterations_method_offset = 23
    _set_max_iterations_method_offset = 24
    _metadata = {
        "iid_data" : (5003032963108949314, 2079494990998510258),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKuttaF7th8th)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_max_relative_err_metadata, value)

    _get_max_absolute_err_metadata = { "offset" : _get_max_absolute_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_err(self) -> float:
        """Get or set the maximum absolute error; Also used if relative scale is too small. Dimensionless."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_max_absolute_err_metadata)

    _set_max_absolute_err_metadata = { "offset" : _set_max_absolute_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_absolute_err.setter
    def max_absolute_err(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_max_absolute_err_metadata, value)

    _get_high_safety_coefficient_metadata = { "offset" : _get_high_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def high_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to decrease step size if the error is too high. Dimensionless."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_high_safety_coefficient_metadata)

    _set_high_safety_coefficient_metadata = { "offset" : _set_high_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @high_safety_coefficient.setter
    def high_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_high_safety_coefficient_metadata, value)

    _get_low_safety_coefficient_metadata = { "offset" : _get_low_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def low_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to increase step size if the error is too low. Dimensionless."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_low_safety_coefficient_metadata)

    _set_low_safety_coefficient_metadata = { "offset" : _set_low_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @low_safety_coefficient.setter
    def low_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_low_safety_coefficient_metadata, value)

    _get_error_control_metadata = { "offset" : _get_error_control_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @property
    def error_control(self) -> "ErrorControl":
        """Get or set the error control method."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_error_control_metadata)

    _set_error_control_metadata = { "offset" : _set_error_control_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @error_control.setter
    def error_control(self, value:"ErrorControl") -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_error_control_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum iterations. Dimensionless."""
        return self._intf.get_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(RungeKuttaF7th8th._metadata, RungeKuttaF7th8th._set_max_iterations_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_absolute_err] = "max_absolute_err"
    _property_names[high_safety_coefficient] = "high_safety_coefficient"
    _property_names[low_safety_coefficient] = "low_safety_coefficient"
    _property_names[error_control] = "error_control"
    _property_names[max_iterations] = "max_iterations"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKuttaF7th8th."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKuttaF7th8th)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKuttaF7th8th, [RungeKuttaF7th8th, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((5576782931552734990, 14700968610991896240), RungeKuttaF7th8th)
agcls.AgTypeNameMap["RungeKuttaF7th8th"] = RungeKuttaF7th8th

class RungeKuttaV8th9th(INumericalIntegrator, SupportsDeleteCallback):
    """Properties for the RK8th9th numerical integrator."""

    _num_methods = 26
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_initial_step_method_offset = 1
    _set_initial_step_method_offset = 2
    _get_use_fixed_step_method_offset = 3
    _set_use_fixed_step_method_offset = 4
    _get_use_max_step_method_offset = 5
    _set_use_max_step_method_offset = 6
    _get_use_min_step_method_offset = 7
    _set_use_min_step_method_offset = 8
    _get_max_step_method_offset = 9
    _set_max_step_method_offset = 10
    _get_min_step_method_offset = 11
    _set_min_step_method_offset = 12
    _get_max_relative_err_method_offset = 13
    _set_max_relative_err_method_offset = 14
    _get_max_absolute_err_method_offset = 15
    _set_max_absolute_err_method_offset = 16
    _get_high_safety_coefficient_method_offset = 17
    _set_high_safety_coefficient_method_offset = 18
    _get_low_safety_coefficient_method_offset = 19
    _set_low_safety_coefficient_method_offset = 20
    _get_error_control_method_offset = 21
    _set_error_control_method_offset = 22
    _get_max_iterations_method_offset = 23
    _set_max_iterations_method_offset = 24
    _get_coefficient_type_method_offset = 25
    _set_coefficient_type_method_offset = 26
    _metadata = {
        "iid_data" : (5129527927042386535, 1794743312009283255),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RungeKuttaV8th9th)

    _get_initial_step_metadata = { "offset" : _get_initial_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_step(self) -> float:
        """Get or set the initial step. Uses time dimension."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_initial_step_metadata)

    _set_initial_step_metadata = { "offset" : _set_initial_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_step.setter
    def initial_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_initial_step_metadata, value)

    _get_use_fixed_step_metadata = { "offset" : _get_use_fixed_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_fixed_step(self) -> bool:
        """True if running in fixed-step mode."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_use_fixed_step_metadata)

    _set_use_fixed_step_metadata = { "offset" : _set_use_fixed_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_fixed_step.setter
    def use_fixed_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_use_fixed_step_metadata, value)

    _get_use_max_step_metadata = { "offset" : _get_use_max_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_step(self) -> bool:
        """Whether or not to enforce the maximum step."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_use_max_step_metadata)

    _set_use_max_step_metadata = { "offset" : _set_use_max_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_step.setter
    def use_max_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_use_max_step_metadata, value)

    _get_use_min_step_metadata = { "offset" : _get_use_min_step_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_step(self) -> bool:
        """Whether or not to enforce the minimum step."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_use_min_step_metadata)

    _set_use_min_step_metadata = { "offset" : _set_use_min_step_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_step.setter
    def use_min_step(self, value:bool) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_use_min_step_metadata, value)

    _get_max_step_metadata = { "offset" : _get_max_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_step(self) -> float:
        """Get or set the maximum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_max_step_metadata)

    _set_max_step_metadata = { "offset" : _set_max_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_step.setter
    def max_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_max_step_metadata, value)

    _get_min_step_metadata = { "offset" : _get_min_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_step(self) -> float:
        """Get or set the minimum step size to allow (absolute value). Uses Time Dimension."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_min_step_metadata)

    _set_min_step_metadata = { "offset" : _set_min_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_step.setter
    def min_step(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_min_step_metadata, value)

    _get_max_relative_err_metadata = { "offset" : _get_max_relative_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_err(self) -> float:
        """Get or set the maximum relative error used to control step size. Dimensionless."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_max_relative_err_metadata)

    _set_max_relative_err_metadata = { "offset" : _set_max_relative_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_err.setter
    def max_relative_err(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_max_relative_err_metadata, value)

    _get_max_absolute_err_metadata = { "offset" : _get_max_absolute_err_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_err(self) -> float:
        """Get or set the maximum absolute error; Also used if relative scale is too small. Dimensionless."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_max_absolute_err_metadata)

    _set_max_absolute_err_metadata = { "offset" : _set_max_absolute_err_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_absolute_err.setter
    def max_absolute_err(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_max_absolute_err_metadata, value)

    _get_high_safety_coefficient_metadata = { "offset" : _get_high_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def high_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to decrease step size if the error is too high. Dimensionless."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_high_safety_coefficient_metadata)

    _set_high_safety_coefficient_metadata = { "offset" : _set_high_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @high_safety_coefficient.setter
    def high_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_high_safety_coefficient_metadata, value)

    _get_low_safety_coefficient_metadata = { "offset" : _get_low_safety_coefficient_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def low_safety_coefficient(self) -> float:
        """Get or set the 'safety' coefficient used to increase step size if the error is too low. Dimensionless."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_low_safety_coefficient_metadata)

    _set_low_safety_coefficient_metadata = { "offset" : _set_low_safety_coefficient_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @low_safety_coefficient.setter
    def low_safety_coefficient(self, value:float) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_low_safety_coefficient_metadata, value)

    _get_error_control_metadata = { "offset" : _get_error_control_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @property
    def error_control(self) -> "ErrorControl":
        """Get or set the error control method."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_error_control_metadata)

    _set_error_control_metadata = { "offset" : _set_error_control_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ErrorControl),) }
    @error_control.setter
    def error_control(self, value:"ErrorControl") -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_error_control_metadata, value)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the maximum iterations. Dimensionless."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_max_iterations_metadata, value)

    _get_coefficient_type_metadata = { "offset" : _get_coefficient_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CoeffRungeKuttaV8th9th),) }
    @property
    def coefficient_type(self) -> "CoeffRungeKuttaV8th9th":
        """Get or set the set of coefficients to use."""
        return self._intf.get_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._get_coefficient_type_metadata)

    _set_coefficient_type_metadata = { "offset" : _set_coefficient_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CoeffRungeKuttaV8th9th),) }
    @coefficient_type.setter
    def coefficient_type(self, value:"CoeffRungeKuttaV8th9th") -> None:
        return self._intf.set_property(RungeKuttaV8th9th._metadata, RungeKuttaV8th9th._set_coefficient_type_metadata, value)

    _property_names[initial_step] = "initial_step"
    _property_names[use_fixed_step] = "use_fixed_step"
    _property_names[use_max_step] = "use_max_step"
    _property_names[use_min_step] = "use_min_step"
    _property_names[max_step] = "max_step"
    _property_names[min_step] = "min_step"
    _property_names[max_relative_err] = "max_relative_err"
    _property_names[max_absolute_err] = "max_absolute_err"
    _property_names[high_safety_coefficient] = "high_safety_coefficient"
    _property_names[low_safety_coefficient] = "low_safety_coefficient"
    _property_names[error_control] = "error_control"
    _property_names[max_iterations] = "max_iterations"
    _property_names[coefficient_type] = "coefficient_type"

    def __init__(self, source_object=None):
        """Construct an object of type RungeKuttaV8th9th."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RungeKuttaV8th9th)
        INumericalIntegrator.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        INumericalIntegrator._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, RungeKuttaV8th9th, [RungeKuttaV8th9th, INumericalIntegrator])

agcls.AgClassCatalog.add_catalog_entry((5675169713119132491, 10165191028029519797), RungeKuttaV8th9th)
agcls.AgTypeNameMap["RungeKuttaV8th9th"] = RungeKuttaV8th9th

class ScriptingTool(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for the Scripting Tool."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_segment_properties_method_offset = 3
    _get_calculation_objects_method_offset = 4
    _get_parameters_method_offset = 5
    _get_language_type_method_offset = 6
    _set_language_type_method_offset = 7
    _script_text_method_offset = 8
    _copy_to_clipboard_method_offset = 9
    _paste_from_clipboard_method_offset = 10
    _get_pre_iterate_method_offset = 11
    _set_pre_iterate_method_offset = 12
    _metadata = {
        "iid_data" : (4663132750434503155, 7930548857949584564),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingTool)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the scripting tool is enabled."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(ScriptingTool._metadata, ScriptingTool._set_enable_metadata, value)

    _get_segment_properties_metadata = { "offset" : _get_segment_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def segment_properties(self) -> "ScriptingSegmentCollection":
        """Return the collection of the segment properties."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_segment_properties_metadata)

    _get_calculation_objects_metadata = { "offset" : _get_calculation_objects_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_objects(self) -> "ScriptingCalculationObjectCollection":
        """Return the collection of the calculation objects."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_calculation_objects_metadata)

    _get_parameters_metadata = { "offset" : _get_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def parameters(self) -> "ScriptingParameterCollection":
        """Return the collection of parameters."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_parameters_metadata)

    _get_language_type_metadata = { "offset" : _get_language_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Language),) }
    @property
    def language_type(self) -> "Language":
        """Get or set the scripting language being used."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_language_type_metadata)

    _set_language_type_metadata = { "offset" : _set_language_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Language),) }
    @language_type.setter
    def language_type(self, value:"Language") -> None:
        return self._intf.set_property(ScriptingTool._metadata, ScriptingTool._set_language_type_metadata, value)

    _script_text_metadata = { "offset" : _script_text_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def script_text(self, script:str) -> None:
        """Injects the script into the scripting tool."""
        return self._intf.invoke(ScriptingTool._metadata, ScriptingTool._script_text_metadata, script)

    _copy_to_clipboard_metadata = { "offset" : _copy_to_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_to_clipboard(self) -> None:
        """Copy entire scripting tool to clipboard."""
        return self._intf.invoke(ScriptingTool._metadata, ScriptingTool._copy_to_clipboard_metadata, )

    _paste_from_clipboard_metadata = { "offset" : _paste_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_from_clipboard(self) -> None:
        """Replace entire scripting tool with scripting tool in clipboard."""
        return self._intf.invoke(ScriptingTool._metadata, ScriptingTool._paste_from_clipboard_metadata, )

    _get_pre_iterate_metadata = { "offset" : _get_pre_iterate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def pre_iterate(self) -> bool:
        """If true, the sequence will run once before executing the script."""
        return self._intf.get_property(ScriptingTool._metadata, ScriptingTool._get_pre_iterate_metadata)

    _set_pre_iterate_metadata = { "offset" : _set_pre_iterate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @pre_iterate.setter
    def pre_iterate(self, value:bool) -> None:
        return self._intf.set_property(ScriptingTool._metadata, ScriptingTool._set_pre_iterate_metadata, value)

    _property_names[enable] = "enable"
    _property_names[segment_properties] = "segment_properties"
    _property_names[calculation_objects] = "calculation_objects"
    _property_names[parameters] = "parameters"
    _property_names[language_type] = "language_type"
    _property_names[pre_iterate] = "pre_iterate"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingTool."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingTool)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingTool, [ScriptingTool, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5386292892735441079, 13900834054744615054), ScriptingTool)
agcls.AgTypeNameMap["ScriptingTool"] = ScriptingTool

class ScriptingSegmentCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The list of object properties that the script can interact with."""

    _num_methods = 12
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _remove_all_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _get_provide_runtime_type_info_method_offset = 7
    _cut_method_offset = 8
    _paste_method_offset = 9
    _insert_copy_method_offset = 10
    _get_item_by_index_method_offset = 11
    _get_item_by_name_method_offset = 12
    _metadata = {
        "iid_data" : (5377494462842049808, 17202565285805206185),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingSegmentCollection)
    def __iter__(self):
        """Create an iterator for the ScriptingSegmentCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ScriptingSegment":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "ScriptingSegment":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, component_name:str) -> "ScriptingSegment":
        """Add an object property to the collection."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._add_metadata, component_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a object property."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all object properties."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._remove_all_metadata, )

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._get_count_metadata)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._get_provide_runtime_type_info_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the object property into the clipboard and removes the object property from the list."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "ScriptingSegment":
        """Pastes the object property from the clipboard and inserts into the list."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ScriptingSegment"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, obj_property:"ScriptingSegment") -> "ScriptingSegment":
        """Copy the object property and inserts the copy into the list."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._insert_copy_metadata, obj_property, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "ScriptingSegment":
        """Retrieve a scripting segment in the collection by index."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "ScriptingSegment":
        """Retrieve a scripting segment in the collection by name."""
        return self._intf.invoke(ScriptingSegmentCollection._metadata, ScriptingSegmentCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingSegmentCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingSegmentCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingSegmentCollection, [ScriptingSegmentCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5747222952172680036, 9765550541896094091), ScriptingSegmentCollection)
agcls.AgTypeNameMap["ScriptingSegmentCollection"] = ScriptingSegmentCollection

class ScriptingSegment(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Object properties for scripting options."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_component_name_method_offset = 1
    _set_component_name_method_offset = 2
    _get_attribute_method_offset = 3
    _set_attribute_method_offset = 4
    _get_unit_method_offset = 5
    _set_unit_method_offset = 6
    _get_available_attribute_values_method_offset = 7
    _get_read_only_property_method_offset = 8
    _set_read_only_property_method_offset = 9
    _get_object_name_method_offset = 10
    _set_object_name_method_offset = 11
    _get_available_object_names_method_offset = 12
    _metadata = {
        "iid_data" : (4879802289783632705, 8146140236855949728),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingSegment)

    _get_component_name_metadata = { "offset" : _get_component_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def component_name(self) -> str:
        """Get or set the name of the component."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_component_name_metadata)

    _set_component_name_metadata = { "offset" : _set_component_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @component_name.setter
    def component_name(self, value:str) -> None:
        return self._intf.set_property(ScriptingSegment._metadata, ScriptingSegment._set_component_name_metadata, value)

    _get_attribute_metadata = { "offset" : _get_attribute_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def attribute(self) -> str:
        """Get or set the name of the attribute."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_attribute_metadata)

    _set_attribute_metadata = { "offset" : _set_attribute_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @attribute.setter
    def attribute(self, value:str) -> None:
        return self._intf.set_property(ScriptingSegment._metadata, ScriptingSegment._set_attribute_metadata, value)

    _get_unit_metadata = { "offset" : _get_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit(self) -> str:
        """Get or set the unit."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_unit_metadata)

    _set_unit_metadata = { "offset" : _set_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit.setter
    def unit(self, value:str) -> None:
        return self._intf.set_property(ScriptingSegment._metadata, ScriptingSegment._set_unit_metadata, value)

    _get_available_attribute_values_metadata = { "offset" : _get_available_attribute_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def available_attribute_values(self) -> list:
        """Return a list of available attribute values."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_available_attribute_values_metadata)

    _get_read_only_property_metadata = { "offset" : _get_read_only_property_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def read_only_property(self) -> bool:
        """True if it is a read-only property."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_read_only_property_metadata)

    _set_read_only_property_metadata = { "offset" : _set_read_only_property_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @read_only_property.setter
    def read_only_property(self, value:bool) -> None:
        return self._intf.set_property(ScriptingSegment._metadata, ScriptingSegment._set_read_only_property_metadata, value)

    _get_object_name_metadata = { "offset" : _get_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def object_name(self) -> str:
        """Get or set the profile/segment that contains the attribute."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_object_name_metadata)

    _set_object_name_metadata = { "offset" : _set_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @object_name.setter
    def object_name(self, value:str) -> None:
        return self._intf.set_property(ScriptingSegment._metadata, ScriptingSegment._set_object_name_metadata, value)

    _get_available_object_names_metadata = { "offset" : _get_available_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def available_object_names(self) -> list:
        """Return a list of available profile/segment names."""
        return self._intf.get_property(ScriptingSegment._metadata, ScriptingSegment._get_available_object_names_metadata)

    _property_names[component_name] = "component_name"
    _property_names[attribute] = "attribute"
    _property_names[unit] = "unit"
    _property_names[available_attribute_values] = "available_attribute_values"
    _property_names[read_only_property] = "read_only_property"
    _property_names[object_name] = "object_name"
    _property_names[available_object_names] = "available_object_names"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingSegment."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingSegment)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingSegment, [ScriptingSegment, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4750376263332927565, 2703854210644328112), ScriptingSegment)
agcls.AgTypeNameMap["ScriptingSegment"] = ScriptingSegment

class ScriptingParameterCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The list of parameters that the script can interact with."""

    _num_methods = 12
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _remove_all_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _get_provide_runtime_type_info_method_offset = 7
    _cut_method_offset = 8
    _paste_method_offset = 9
    _insert_copy_method_offset = 10
    _get_item_by_index_method_offset = 11
    _get_item_by_name_method_offset = 12
    _metadata = {
        "iid_data" : (4902261710191863466, 8162432943313407620),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingParameterCollection)
    def __iter__(self):
        """Create an iterator for the ScriptingParameterCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ScriptingParameter":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "ScriptingParameter":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, parameter_name:str) -> "ScriptingParameter":
        """Add a parameter to the collection."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._add_metadata, parameter_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a parameter."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all parameters."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._remove_all_metadata, )

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ScriptingParameterCollection._metadata, ScriptingParameterCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ScriptingParameterCollection._metadata, ScriptingParameterCollection._get_count_metadata)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ScriptingParameterCollection._metadata, ScriptingParameterCollection._get_provide_runtime_type_info_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the parameter into the clipboard and removes the parameter from the list."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "ScriptingParameter":
        """Pastes the parameter from the clipboard and inserts into the list."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ScriptingParameter"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, parameter:"ScriptingParameter") -> "ScriptingParameter":
        """Copy the parameter and inserts the copy into the list."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._insert_copy_metadata, parameter, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "ScriptingParameter":
        """Retrieve a scripting parameter in the collection by index."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "ScriptingParameter":
        """Retrieve a scripting parameter in the collection by name."""
        return self._intf.invoke(ScriptingParameterCollection._metadata, ScriptingParameterCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingParameterCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingParameterCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingParameterCollection, [ScriptingParameterCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4890502539091661881, 1580839912369041288), ScriptingParameterCollection)
agcls.AgTypeNameMap["ScriptingParameterCollection"] = ScriptingParameterCollection

class ScriptingParameter(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Parameter properties for scripting options."""

    _num_methods = 23
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_parameter_value_method_offset = 3
    _set_parameter_value_method_offset = 4
    _get_unit_method_offset = 5
    _set_unit_method_offset = 6
    _get_type_method_offset = 7
    _set_type_method_offset = 8
    _get_inherit_value_method_offset = 9
    _set_inherit_value_method_offset = 10
    _get_user_comment_method_offset = 11
    _set_user_comment_method_offset = 12
    _get_dimension_method_offset = 13
    _set_dimension_method_offset = 14
    _get_enumeration_choices_method_offset = 15
    _get_use_min_value_method_offset = 16
    _set_use_min_value_method_offset = 17
    _get_min_value_method_offset = 18
    _set_min_value_method_offset = 19
    _get_use_max_value_method_offset = 20
    _set_use_max_value_method_offset = 21
    _get_max_value_method_offset = 22
    _set_max_value_method_offset = 23
    _metadata = {
        "iid_data" : (5574668373759188189, 12962501081415056814),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingParameter)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get or set the parameter name."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_name_metadata, value)

    _get_parameter_value_metadata = { "offset" : _get_parameter_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def parameter_value(self) -> typing.Any:
        """Get or set the parameter value.  Set in Object Model unit preference for selected dimension."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_parameter_value_metadata)

    _set_parameter_value_metadata = { "offset" : _set_parameter_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @parameter_value.setter
    def parameter_value(self, value:typing.Any) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_parameter_value_metadata, value)

    _get_unit_metadata = { "offset" : _get_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit(self) -> str:
        """Get or set the parameter's unit that is used to represent ParamValue during the scripting tool script execution. ParamValue is set in Object Model unit preference for selected dimension and not this unit. As with other units configurable in the desktop environment for STK, this unit is separate (and may differ) from the Object Model unit preference."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_unit_metadata)

    _set_unit_metadata = { "offset" : _set_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit.setter
    def unit(self, value:str) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_unit_metadata, value)

    _get_type_metadata = { "offset" : _get_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ScriptingParameterType),) }
    @property
    def type(self) -> "ScriptingParameterType":
        """Get or set the parameter's type."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_type_metadata)

    _set_type_metadata = { "offset" : _set_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ScriptingParameterType),) }
    @type.setter
    def type(self, value:"ScriptingParameterType") -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_type_metadata, value)

    _get_inherit_value_metadata = { "offset" : _get_inherit_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def inherit_value(self) -> bool:
        """If true, parameter value will be inherited from previous profile's value."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_inherit_value_metadata)

    _set_inherit_value_metadata = { "offset" : _set_inherit_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @inherit_value.setter
    def inherit_value(self, value:bool) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_inherit_value_metadata, value)

    _get_user_comment_metadata = { "offset" : _get_user_comment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def user_comment(self) -> str:
        """Get or set the parameter's comment."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_user_comment_metadata)

    _set_user_comment_metadata = { "offset" : _set_user_comment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @user_comment.setter
    def user_comment(self, value:str) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_user_comment_metadata, value)

    _get_dimension_metadata = { "offset" : _get_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def dimension(self) -> str:
        """Get or set the parameter's dimension."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_dimension_metadata)

    _set_dimension_metadata = { "offset" : _set_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @dimension.setter
    def dimension(self, value:str) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_dimension_metadata, value)

    _get_enumeration_choices_metadata = { "offset" : _get_enumeration_choices_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enumeration_choices(self) -> "ScriptingParameterEnumerationChoiceCollection":
        """Get the collection of enumerations to use when parameter type is eVAScriptingParameterTypeEnumeration."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_enumeration_choices_metadata)

    _get_use_min_value_metadata = { "offset" : _get_use_min_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_value(self) -> bool:
        """If true, a minimum value will be enforced for the parameter value."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_use_min_value_metadata)

    _set_use_min_value_metadata = { "offset" : _set_use_min_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_min_value.setter
    def use_min_value(self, value:bool) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_use_min_value_metadata, value)

    _get_min_value_metadata = { "offset" : _get_min_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_value(self) -> typing.Any:
        """Get or set the minimum value permitted for the parameter value."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_min_value_metadata)

    _set_min_value_metadata = { "offset" : _set_min_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @min_value.setter
    def min_value(self, value:typing.Any) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_min_value_metadata, value)

    _get_use_max_value_metadata = { "offset" : _get_use_max_value_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_value(self) -> bool:
        """If true, a maximum value will be enforced for the parameter value."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_use_max_value_metadata)

    _set_use_max_value_metadata = { "offset" : _set_use_max_value_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_value.setter
    def use_max_value(self, value:bool) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_use_max_value_metadata, value)

    _get_max_value_metadata = { "offset" : _get_max_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_value(self) -> typing.Any:
        """Get or set the maximum value permitted for the parameter value."""
        return self._intf.get_property(ScriptingParameter._metadata, ScriptingParameter._get_max_value_metadata)

    _set_max_value_metadata = { "offset" : _set_max_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_value.setter
    def max_value(self, value:typing.Any) -> None:
        return self._intf.set_property(ScriptingParameter._metadata, ScriptingParameter._set_max_value_metadata, value)

    _property_names[name] = "name"
    _property_names[parameter_value] = "parameter_value"
    _property_names[unit] = "unit"
    _property_names[type] = "type"
    _property_names[inherit_value] = "inherit_value"
    _property_names[user_comment] = "user_comment"
    _property_names[dimension] = "dimension"
    _property_names[enumeration_choices] = "enumeration_choices"
    _property_names[use_min_value] = "use_min_value"
    _property_names[min_value] = "min_value"
    _property_names[use_max_value] = "use_max_value"
    _property_names[max_value] = "max_value"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingParameter."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingParameter)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingParameter, [ScriptingParameter, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5251359406070671618, 17193361196137710260), ScriptingParameter)
agcls.AgTypeNameMap["ScriptingParameter"] = ScriptingParameter

class ScriptingCalculationObject(SupportsDeleteCallback):
    """Calc Object properties for scripting options."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_component_name_method_offset = 1
    _set_component_name_method_offset = 2
    _get_calculation_object_name_method_offset = 3
    _set_calculation_object_name_method_offset = 4
    _get_calculation_object_method_offset = 5
    _set_calculation_object_method_offset = 6
    _get_unit_method_offset = 7
    _set_unit_method_offset = 8
    _copy_calculation_object_to_clipboard_method_offset = 9
    _paste_calculation_object_from_clipboard_method_offset = 10
    _metadata = {
        "iid_data" : (4858284977774556021, 17365740631458954930),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingCalculationObject)

    _get_component_name_metadata = { "offset" : _get_component_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def component_name(self) -> str:
        """Get or set the name of the component."""
        return self._intf.get_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._get_component_name_metadata)

    _set_component_name_metadata = { "offset" : _set_component_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @component_name.setter
    def component_name(self, value:str) -> None:
        return self._intf.set_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._set_component_name_metadata, value)

    _get_calculation_object_name_metadata = { "offset" : _get_calculation_object_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def calculation_object_name(self) -> str:
        """Get or set the name of the calculation object."""
        return self._intf.get_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._get_calculation_object_name_metadata)

    _set_calculation_object_name_metadata = { "offset" : _set_calculation_object_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @calculation_object_name.setter
    def calculation_object_name(self, value:str) -> None:
        return self._intf.set_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._set_calculation_object_name_metadata, value)

    _get_calculation_object_metadata = { "offset" : _get_calculation_object_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_object(self) -> "IComponentInfo":
        """Get or set the calculation object type."""
        return self._intf.get_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._get_calculation_object_metadata)

    _set_calculation_object_metadata = { "offset" : _set_calculation_object_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentInfo"),) }
    @calculation_object.setter
    def calculation_object(self, value:"IComponentInfo") -> None:
        return self._intf.set_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._set_calculation_object_metadata, value)

    _get_unit_metadata = { "offset" : _get_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit(self) -> str:
        """Get or set the unit."""
        return self._intf.get_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._get_unit_metadata)

    _set_unit_metadata = { "offset" : _set_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit.setter
    def unit(self, value:str) -> None:
        return self._intf.set_property(ScriptingCalculationObject._metadata, ScriptingCalculationObject._set_unit_metadata, value)

    _copy_calculation_object_to_clipboard_metadata = { "offset" : _copy_calculation_object_to_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_calculation_object_to_clipboard(self) -> None:
        """Copy the wrapped calc object to the clipboard."""
        return self._intf.invoke(ScriptingCalculationObject._metadata, ScriptingCalculationObject._copy_calculation_object_to_clipboard_metadata, )

    _paste_calculation_object_from_clipboard_metadata = { "offset" : _paste_calculation_object_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_calculation_object_from_clipboard(self) -> None:
        """Replace the wrapped calc object with the instance in the clipboard."""
        return self._intf.invoke(ScriptingCalculationObject._metadata, ScriptingCalculationObject._paste_calculation_object_from_clipboard_metadata, )

    _property_names[component_name] = "component_name"
    _property_names[calculation_object_name] = "calculation_object_name"
    _property_names[calculation_object] = "calculation_object"
    _property_names[unit] = "unit"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingCalculationObject."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingCalculationObject)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingCalculationObject, [ScriptingCalculationObject, ])

agcls.AgClassCatalog.add_catalog_entry((5296189893641852469, 9482879366663785884), ScriptingCalculationObject)
agcls.AgTypeNameMap["ScriptingCalculationObject"] = ScriptingCalculationObject

class ScriptingCalculationObjectCollection(SupportsDeleteCallback):
    """The list of calc objects that the script can interact with."""

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _remove_all_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _cut_method_offset = 7
    _paste_method_offset = 8
    _insert_copy_method_offset = 9
    _get_item_by_index_method_offset = 10
    _get_item_by_name_method_offset = 11
    _metadata = {
        "iid_data" : (5107928153766242116, 14842271196491693998),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingCalculationObjectCollection)
    def __iter__(self):
        """Create an iterator for the ScriptingCalculationObjectCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ScriptingCalculationObject":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "ScriptingCalculationObject":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, component_name:str) -> "ScriptingCalculationObject":
        """Add a calculation object to the collection."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._add_metadata, component_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a calculation object."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all calculation objects."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._remove_all_metadata, )

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the calc object into the clipboard and removes the calc object from the list."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "ScriptingCalculationObject":
        """Pastes the calc object from the clipboard and inserts into the list."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ScriptingCalculationObject"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, calc_obj:"ScriptingCalculationObject") -> "ScriptingCalculationObject":
        """Copy the calc object and inserts the copy into the list."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._insert_copy_metadata, calc_obj, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "ScriptingCalculationObject":
        """Retrieve a scripting calc object from the collection by index."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, component_name:str) -> "ScriptingCalculationObject":
        """Retrieve a scripting calc object from the collection by name."""
        return self._intf.invoke(ScriptingCalculationObjectCollection._metadata, ScriptingCalculationObjectCollection._get_item_by_name_metadata, component_name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingCalculationObjectCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingCalculationObjectCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingCalculationObjectCollection, [ScriptingCalculationObjectCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4980684683189716790, 9229952429326373522), ScriptingCalculationObjectCollection)
agcls.AgTypeNameMap["ScriptingCalculationObjectCollection"] = ScriptingCalculationObjectCollection

class UserVariableDefinition(SupportsDeleteCallback):
    """Properties for a User Variable definition."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_unit_dimension_method_offset = 1
    _set_unit_dimension_method_offset = 2
    _get_variable_name_method_offset = 3
    _set_variable_name_method_offset = 4
    _metadata = {
        "iid_data" : (5529170653593380386, 2900532398815823505),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariableDefinition)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get or set the dimension of the user variable."""
        return self._intf.get_property(UserVariableDefinition._metadata, UserVariableDefinition._get_unit_dimension_metadata)

    _set_unit_dimension_metadata = { "offset" : _set_unit_dimension_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @unit_dimension.setter
    def unit_dimension(self, value:str) -> None:
        """Get or set the dimension of the user variable."""
        return self._intf.set_property(UserVariableDefinition._metadata, UserVariableDefinition._set_unit_dimension_metadata, value)

    _get_variable_name_metadata = { "offset" : _get_variable_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_name(self) -> str:
        """Get or set the name of the user variable."""
        return self._intf.get_property(UserVariableDefinition._metadata, UserVariableDefinition._get_variable_name_metadata)

    _set_variable_name_metadata = { "offset" : _set_variable_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @variable_name.setter
    def variable_name(self, value:str) -> None:
        """Get or set the name of the user variable."""
        return self._intf.set_property(UserVariableDefinition._metadata, UserVariableDefinition._set_variable_name_metadata, value)

    _property_names[unit_dimension] = "unit_dimension"
    _property_names[variable_name] = "variable_name"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariableDefinition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariableDefinition)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariableDefinition, [UserVariableDefinition, ])

agcls.AgClassCatalog.add_catalog_entry((5176854942637247565, 2244191041652103592), UserVariableDefinition)
agcls.AgTypeNameMap["UserVariableDefinition"] = UserVariableDefinition

class UserVariable(SupportsDeleteCallback):
    """The properties for a User Variable initial value."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_unit_dimension_method_offset = 1
    _get_variable_name_method_offset = 2
    _get_variable_value_method_offset = 3
    _set_variable_value_method_offset = 4
    _enable_control_parameter_method_offset = 5
    _disable_control_parameter_method_offset = 6
    _is_control_parameter_enabled_method_offset = 7
    _get_control_parameters_available_method_offset = 8
    _metadata = {
        "iid_data" : (5102207211866036182, 1394843534775836036),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariable)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get the dimension of the user variable."""
        return self._intf.get_property(UserVariable._metadata, UserVariable._get_unit_dimension_metadata)

    _get_variable_name_metadata = { "offset" : _get_variable_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_name(self) -> str:
        """Set the name of the user variable."""
        return self._intf.get_property(UserVariable._metadata, UserVariable._get_variable_name_metadata)

    _get_variable_value_metadata = { "offset" : _get_variable_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def variable_value(self) -> typing.Any:
        """Get or set the initial value of the user variable."""
        return self._intf.get_property(UserVariable._metadata, UserVariable._get_variable_value_metadata)

    _set_variable_value_metadata = { "offset" : _set_variable_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @variable_value.setter
    def variable_value(self, value:typing.Any) -> None:
        """Get or set the initial value of the user variable."""
        return self._intf.set_property(UserVariable._metadata, UserVariable._set_variable_value_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def enable_control_parameter(self) -> None:
        """Enable or disables the specified control parameter."""
        return self._intf.invoke(UserVariable._metadata, UserVariable._enable_control_parameter_metadata, )

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def disable_control_parameter(self) -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(UserVariable._metadata, UserVariable._disable_control_parameter_metadata, )

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self) -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(UserVariable._metadata, UserVariable._is_control_parameter_enabled_metadata, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(UserVariable._metadata, UserVariable._get_control_parameters_available_metadata)

    _property_names[unit_dimension] = "unit_dimension"
    _property_names[variable_name] = "variable_name"
    _property_names[variable_value] = "variable_value"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariable."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariable)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariable, [UserVariable, ])

agcls.AgClassCatalog.add_catalog_entry((5297374455989115384, 13571318339920513665), UserVariable)
agcls.AgTypeNameMap["UserVariable"] = UserVariable

class UserVariableUpdate(SupportsDeleteCallback):
    """Properties for a User Variable update."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_unit_dimension_method_offset = 1
    _get_variable_name_method_offset = 2
    _get_variable_value_method_offset = 3
    _set_variable_value_method_offset = 4
    _get_variable_action_method_offset = 5
    _set_variable_action_method_offset = 6
    _enable_control_parameter_method_offset = 7
    _disable_control_parameter_method_offset = 8
    _is_control_parameter_enabled_method_offset = 9
    _get_control_parameters_available_method_offset = 10
    _metadata = {
        "iid_data" : (4670752174265368180, 17869180467884326790),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariableUpdate)

    _get_unit_dimension_metadata = { "offset" : _get_unit_dimension_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def unit_dimension(self) -> str:
        """Get the dimension of the user variable."""
        return self._intf.get_property(UserVariableUpdate._metadata, UserVariableUpdate._get_unit_dimension_metadata)

    _get_variable_name_metadata = { "offset" : _get_variable_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def variable_name(self) -> str:
        """Get the name of the user variable."""
        return self._intf.get_property(UserVariableUpdate._metadata, UserVariableUpdate._get_variable_name_metadata)

    _get_variable_value_metadata = { "offset" : _get_variable_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def variable_value(self) -> typing.Any:
        """Update value of the user variable."""
        return self._intf.get_property(UserVariableUpdate._metadata, UserVariableUpdate._get_variable_value_metadata)

    _set_variable_value_metadata = { "offset" : _set_variable_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @variable_value.setter
    def variable_value(self, value:typing.Any) -> None:
        return self._intf.set_property(UserVariableUpdate._metadata, UserVariableUpdate._set_variable_value_metadata, value)

    _get_variable_action_metadata = { "offset" : _get_variable_action_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(UpdateAction),) }
    @property
    def variable_action(self) -> "UpdateAction":
        """Action to be performed using the value."""
        return self._intf.get_property(UserVariableUpdate._metadata, UserVariableUpdate._get_variable_action_metadata)

    _set_variable_action_metadata = { "offset" : _set_variable_action_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(UpdateAction),) }
    @variable_action.setter
    def variable_action(self, value:"UpdateAction") -> None:
        return self._intf.set_property(UserVariableUpdate._metadata, UserVariableUpdate._set_variable_action_metadata, value)

    _enable_control_parameter_metadata = { "offset" : _enable_control_parameter_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def enable_control_parameter(self) -> None:
        """Enable or disables the specified control parameter."""
        return self._intf.invoke(UserVariableUpdate._metadata, UserVariableUpdate._enable_control_parameter_metadata, )

    _disable_control_parameter_metadata = { "offset" : _disable_control_parameter_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def disable_control_parameter(self) -> None:
        """Disables the specified control parameter."""
        return self._intf.invoke(UserVariableUpdate._metadata, UserVariableUpdate._disable_control_parameter_metadata, )

    _is_control_parameter_enabled_metadata = { "offset" : _is_control_parameter_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    def is_control_parameter_enabled(self) -> bool:
        """Sees if the specified control is enabled."""
        return self._intf.invoke(UserVariableUpdate._metadata, UserVariableUpdate._is_control_parameter_enabled_metadata, OutArg())

    _get_control_parameters_available_metadata = { "offset" : _get_control_parameters_available_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_parameters_available(self) -> bool:
        """Return whether or not the control parameters can be set."""
        return self._intf.get_property(UserVariableUpdate._metadata, UserVariableUpdate._get_control_parameters_available_metadata)

    _property_names[unit_dimension] = "unit_dimension"
    _property_names[variable_name] = "variable_name"
    _property_names[variable_value] = "variable_value"
    _property_names[variable_action] = "variable_action"
    _property_names[control_parameters_available] = "control_parameters_available"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariableUpdate."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariableUpdate)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariableUpdate, [UserVariableUpdate, ])

agcls.AgClassCatalog.add_catalog_entry((4882327334920636266, 17132518977558649745), UserVariableUpdate)
agcls.AgTypeNameMap["UserVariableUpdate"] = UserVariableUpdate

class UserVariableDefinitionCollection(SupportsDeleteCallback):
    """The list of User Variables accessed through the Driver."""

    _num_methods = 8
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _remove_all_method_offset = 4
    _get__new_enum_method_offset = 5
    _get_count_method_offset = 6
    _get_item_by_index_method_offset = 7
    _get_item_by_name_method_offset = 8
    _metadata = {
        "iid_data" : (5470704527173093908, 13614551030675263652),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariableDefinitionCollection)
    def __iter__(self):
        """Create an iterator for the UserVariableDefinitionCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "UserVariableDefinition":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "UserVariableDefinition":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, parameter_name:str) -> "UserVariableDefinition":
        """Add a user variable to the collection."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._add_metadata, parameter_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a user variable."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._remove_metadata, index_or_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all user variables."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._remove_all_metadata, )

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "UserVariableDefinition":
        """Retrieve a user variable definition in the collection by index."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "UserVariableDefinition":
        """Retrieve a user variable definition in the collection by name."""
        return self._intf.invoke(UserVariableDefinitionCollection._metadata, UserVariableDefinitionCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariableDefinitionCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariableDefinitionCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariableDefinitionCollection, [UserVariableDefinitionCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5638480263077990789, 8497446502851080127), UserVariableDefinitionCollection)
agcls.AgTypeNameMap["UserVariableDefinitionCollection"] = UserVariableDefinitionCollection

class UserVariableCollection(SupportsDeleteCallback):
    """The list of User Variables accessed through a segment that sets initial conditions."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_item_by_index_method_offset = 4
    _get_item_by_name_method_offset = 5
    _metadata = {
        "iid_data" : (5705306334517654460, 13719441307500405395),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariableCollection)
    def __iter__(self):
        """Create an iterator for the UserVariableCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "UserVariable":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "UserVariable":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(UserVariableCollection._metadata, UserVariableCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(UserVariableCollection._metadata, UserVariableCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(UserVariableCollection._metadata, UserVariableCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "UserVariable":
        """Retrieve a user variable in the collection by index."""
        return self._intf.invoke(UserVariableCollection._metadata, UserVariableCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "UserVariable":
        """Retrieve a user variable in the collection by name."""
        return self._intf.invoke(UserVariableCollection._metadata, UserVariableCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariableCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariableCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariableCollection, [UserVariableCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5475744921255961082, 2914707611325759872), UserVariableCollection)
agcls.AgTypeNameMap["UserVariableCollection"] = UserVariableCollection

class UserVariableUpdateCollection(SupportsDeleteCallback):
    """The list of User Variables accessed through an Update segment."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_item_by_index_method_offset = 4
    _get_item_by_name_method_offset = 5
    _metadata = {
        "iid_data" : (5192861693448909451, 7822980997782731710),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVariableUpdateCollection)
    def __iter__(self):
        """Create an iterator for the UserVariableUpdateCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "UserVariableUpdate":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "UserVariableUpdate":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(UserVariableUpdateCollection._metadata, UserVariableUpdateCollection._item_metadata, index_or_name, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(UserVariableUpdateCollection._metadata, UserVariableUpdateCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(UserVariableUpdateCollection._metadata, UserVariableUpdateCollection._get_count_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "UserVariableUpdate":
        """Retrieve a user variable update in the collection by index."""
        return self._intf.invoke(UserVariableUpdateCollection._metadata, UserVariableUpdateCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "UserVariableUpdate":
        """Retrieve a user variable update in the collection by name."""
        return self._intf.invoke(UserVariableUpdateCollection._metadata, UserVariableUpdateCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type UserVariableUpdateCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, UserVariableUpdateCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, UserVariableUpdateCollection, [UserVariableUpdateCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4747161639227059513, 4742269417223348868), UserVariableUpdateCollection)
agcls.AgTypeNameMap["UserVariableUpdateCollection"] = UserVariableUpdateCollection

class CalculationGraphCollection(SupportsDeleteCallback):
    """The list of Calculations Graphs to display."""

    _num_methods = 6
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _add_method_offset = 3
    _remove_method_offset = 4
    _remove_all_method_offset = 5
    _get_count_method_offset = 6
    _metadata = {
        "iid_data" : (4825792128715941832, 18011952732228699781),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CalculationGraphCollection)
    def __iter__(self):
        """Create an iterator for the CalculationGraphCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> str:
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.LongArg, agmarshall.BStrArg,) }
    def item(self, index:int) -> str:
        """Allow you to iterate through the collection."""
        return self._intf.invoke(CalculationGraphCollection._metadata, CalculationGraphCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(CalculationGraphCollection._metadata, CalculationGraphCollection._get__new_enum_metadata)

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def add(self, graph_name:str) -> None:
        """Add a calculation graph."""
        return self._intf.invoke(CalculationGraphCollection._metadata, CalculationGraphCollection._add_metadata, graph_name)

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove(self, graph_name:str) -> None:
        """Remove a parameter."""
        return self._intf.invoke(CalculationGraphCollection._metadata, CalculationGraphCollection._remove_metadata, graph_name)

    _remove_all_metadata = { "offset" : _remove_all_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_all(self) -> None:
        """Remove all parameters."""
        return self._intf.invoke(CalculationGraphCollection._metadata, CalculationGraphCollection._remove_all_metadata, )

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(CalculationGraphCollection._metadata, CalculationGraphCollection._get_count_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type CalculationGraphCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CalculationGraphCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CalculationGraphCollection, [CalculationGraphCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5083290063025081319, 11449288902000481971), CalculationGraphCollection)
agcls.AgTypeNameMap["CalculationGraphCollection"] = CalculationGraphCollection

class ScriptingParameterEnumerationChoice(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Enumeration choice."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_value_method_offset = 3
    _set_value_method_offset = 4
    _metadata = {
        "iid_data" : (4694284698603687135, 9562347633715624110),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingParameterEnumerationChoice)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Name of the enumeration."""
        return self._intf.get_property(ScriptingParameterEnumerationChoice._metadata, ScriptingParameterEnumerationChoice._get_name_metadata)

    _set_name_metadata = { "offset" : _set_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @name.setter
    def name(self, value:str) -> None:
        return self._intf.set_property(ScriptingParameterEnumerationChoice._metadata, ScriptingParameterEnumerationChoice._set_name_metadata, value)

    _get_value_metadata = { "offset" : _get_value_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def value(self) -> int:
        """Integer value of the enumeration."""
        return self._intf.get_property(ScriptingParameterEnumerationChoice._metadata, ScriptingParameterEnumerationChoice._get_value_metadata)

    _set_value_metadata = { "offset" : _set_value_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @value.setter
    def value(self, value:int) -> None:
        return self._intf.set_property(ScriptingParameterEnumerationChoice._metadata, ScriptingParameterEnumerationChoice._set_value_metadata, value)

    _property_names[name] = "name"
    _property_names[value] = "value"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingParameterEnumerationChoice."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingParameterEnumerationChoice)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingParameterEnumerationChoice, [ScriptingParameterEnumerationChoice, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5753527390070997698, 16891583172060726955), ScriptingParameterEnumerationChoice)
agcls.AgTypeNameMap["ScriptingParameterEnumerationChoice"] = ScriptingParameterEnumerationChoice

class ScriptingParameterEnumerationChoiceCollection(IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """The list of enumeration choices available when parameter type is Enumeration."""

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _add_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _cut_method_offset = 6
    _paste_method_offset = 7
    _insert_copy_method_offset = 8
    _get_provide_runtime_type_info_method_offset = 9
    _get_item_by_index_method_offset = 10
    _get_item_by_name_method_offset = 11
    _metadata = {
        "iid_data" : (4745458710490589844, 11574573708867379850),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ScriptingParameterEnumerationChoiceCollection)
    def __iter__(self):
        """Create an iterator for the ScriptingParameterEnumerationChoiceCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ScriptingParameterEnumerationChoice":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "ScriptingParameterEnumerationChoice":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._item_metadata, index_or_name, OutArg())

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add(self, choice_name:str) -> "ScriptingParameterEnumerationChoice":
        """Add an enumeration choice to the collection."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._add_metadata, choice_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove an enumeration choice."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy the enumeration choice into the clipboard and removes the enumeration choice from the list."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "ScriptingParameterEnumerationChoice":
        """Pastes the enumeration choice from the clipboard and inserts into the list."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("ScriptingParameterEnumerationChoice"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, choice:"ScriptingParameterEnumerationChoice") -> "ScriptingParameterEnumerationChoice":
        """Copy the enumeration choice and inserts the copy into the list."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._insert_copy_metadata, choice, OutArg())

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._get_provide_runtime_type_info_metadata)

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "ScriptingParameterEnumerationChoice":
        """Retrieve a scripting parameter enumeration choice in the collection by index."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "ScriptingParameterEnumerationChoice":
        """Retrieve a scripting parameter enumeration choice in the collection by name."""
        return self._intf.invoke(ScriptingParameterEnumerationChoiceCollection._metadata, ScriptingParameterEnumerationChoiceCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ScriptingParameterEnumerationChoiceCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ScriptingParameterEnumerationChoiceCollection)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ScriptingParameterEnumerationChoiceCollection, [ScriptingParameterEnumerationChoiceCollection, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4758918111060636034, 3872610572386515628), ScriptingParameterEnumerationChoiceCollection)
agcls.AgTypeNameMap["ScriptingParameterEnumerationChoiceCollection"] = ScriptingParameterEnumerationChoiceCollection

class ProfileSNOPTOptimizer(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties of SNOPT Optimizer profile."""

    _num_methods = 22
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_control_parameters_method_offset = 1
    _get_results_method_offset = 2
    _get_targeter_graphs_method_offset = 3
    _get_scripting_tool_method_offset = 4
    _get_reset_controls_before_run_method_offset = 5
    _set_reset_controls_before_run_method_offset = 6
    _get_max_major_iterations_method_offset = 7
    _set_max_major_iterations_method_offset = 8
    _get_tolerance_on_major_feasibility_method_offset = 9
    _set_tolerance_on_major_feasibility_method_offset = 10
    _get_tolerance_on_major_optimality_method_offset = 11
    _set_tolerance_on_major_optimality_method_offset = 12
    _get_max_minor_iterations_method_offset = 13
    _set_max_minor_iterations_method_offset = 14
    _get_tolerance_on_minor_feasibility_method_offset = 15
    _set_tolerance_on_minor_feasibility_method_offset = 16
    _get_tolerance_on_minor_optimality_method_offset = 17
    _set_tolerance_on_minor_optimality_method_offset = 18
    _get_options_filename_method_offset = 19
    _set_options_filename_method_offset = 20
    _get_allow_internal_primal_infeasibility_measure_normalization_method_offset = 21
    _set_allow_internal_primal_infeasibility_measure_normalization_method_offset = 22
    _metadata = {
        "iid_data" : (5270666790947867762, 11607595184192645561),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileSNOPTOptimizer)

    _get_control_parameters_metadata = { "offset" : _get_control_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def control_parameters(self) -> "SNOPTControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_control_parameters_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "SNOPTResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_results_metadata)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_targeter_graphs_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_scripting_tool_metadata)

    _get_reset_controls_before_run_metadata = { "offset" : _get_reset_controls_before_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reset_controls_before_run(self) -> bool:
        """Reset controls before each run."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_reset_controls_before_run_metadata)

    _set_reset_controls_before_run_metadata = { "offset" : _set_reset_controls_before_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reset_controls_before_run.setter
    def reset_controls_before_run(self, value:bool) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_reset_controls_before_run_metadata, value)

    _get_max_major_iterations_metadata = { "offset" : _get_max_major_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_major_iterations(self) -> int:
        """Get or set the maximum number of major iterations allowed."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_max_major_iterations_metadata)

    _set_max_major_iterations_metadata = { "offset" : _set_max_major_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_major_iterations.setter
    def max_major_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_max_major_iterations_metadata, value)

    _get_tolerance_on_major_feasibility_metadata = { "offset" : _get_tolerance_on_major_feasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_major_feasibility(self) -> float:
        """Specify how accurately the nonlinear constraints should be satisfied."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_tolerance_on_major_feasibility_metadata)

    _set_tolerance_on_major_feasibility_metadata = { "offset" : _set_tolerance_on_major_feasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_major_feasibility.setter
    def tolerance_on_major_feasibility(self, value:float) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_tolerance_on_major_feasibility_metadata, value)

    _get_tolerance_on_major_optimality_metadata = { "offset" : _get_tolerance_on_major_optimality_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_major_optimality(self) -> float:
        """Specify the final accuracy of the dual variables."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_tolerance_on_major_optimality_metadata)

    _set_tolerance_on_major_optimality_metadata = { "offset" : _set_tolerance_on_major_optimality_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_major_optimality.setter
    def tolerance_on_major_optimality(self, value:float) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_tolerance_on_major_optimality_metadata, value)

    _get_max_minor_iterations_metadata = { "offset" : _get_max_minor_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_minor_iterations(self) -> int:
        """Get or set the maximum number of iterations for the QP subproblem allowed during a single major iteration."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_max_minor_iterations_metadata)

    _set_max_minor_iterations_metadata = { "offset" : _set_max_minor_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_minor_iterations.setter
    def max_minor_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_max_minor_iterations_metadata, value)

    _get_tolerance_on_minor_feasibility_metadata = { "offset" : _get_tolerance_on_minor_feasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_minor_feasibility(self) -> float:
        """Get or set the tolerance which the QP subproblem must meet before being considered feasible."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_tolerance_on_minor_feasibility_metadata)

    _set_tolerance_on_minor_feasibility_metadata = { "offset" : _set_tolerance_on_minor_feasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_minor_feasibility.setter
    def tolerance_on_minor_feasibility(self, value:float) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_tolerance_on_minor_feasibility_metadata, value)

    _get_tolerance_on_minor_optimality_metadata = { "offset" : _get_tolerance_on_minor_optimality_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_minor_optimality(self) -> float:
        """Undocumented in the SNOPT literature, and included here for completeness in terms of tolerance options."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_tolerance_on_minor_optimality_metadata)

    _set_tolerance_on_minor_optimality_metadata = { "offset" : _set_tolerance_on_minor_optimality_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_minor_optimality.setter
    def tolerance_on_minor_optimality(self, value:float) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_tolerance_on_minor_optimality_metadata, value)

    _get_options_filename_metadata = { "offset" : _get_options_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def options_filename(self) -> str:
        """If used, the associated SNOPT specifications file may define any of the various SNOPT options. Options in the file that conflict with options specified elsewhere will take precedence."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_options_filename_metadata)

    _set_options_filename_metadata = { "offset" : _set_options_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @options_filename.setter
    def options_filename(self, value:str) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_options_filename_metadata, value)

    _get_allow_internal_primal_infeasibility_measure_normalization_metadata = { "offset" : _get_allow_internal_primal_infeasibility_measure_normalization_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def allow_internal_primal_infeasibility_measure_normalization(self) -> bool:
        """Whether to allow internal normalization of the primal infeasibility measure."""
        return self._intf.get_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._get_allow_internal_primal_infeasibility_measure_normalization_metadata)

    _set_allow_internal_primal_infeasibility_measure_normalization_metadata = { "offset" : _set_allow_internal_primal_infeasibility_measure_normalization_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @allow_internal_primal_infeasibility_measure_normalization.setter
    def allow_internal_primal_infeasibility_measure_normalization(self, value:bool) -> None:
        return self._intf.set_property(ProfileSNOPTOptimizer._metadata, ProfileSNOPTOptimizer._set_allow_internal_primal_infeasibility_measure_normalization_metadata, value)

    _property_names[control_parameters] = "control_parameters"
    _property_names[results] = "results"
    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[reset_controls_before_run] = "reset_controls_before_run"
    _property_names[max_major_iterations] = "max_major_iterations"
    _property_names[tolerance_on_major_feasibility] = "tolerance_on_major_feasibility"
    _property_names[tolerance_on_major_optimality] = "tolerance_on_major_optimality"
    _property_names[max_minor_iterations] = "max_minor_iterations"
    _property_names[tolerance_on_minor_feasibility] = "tolerance_on_minor_feasibility"
    _property_names[tolerance_on_minor_optimality] = "tolerance_on_minor_optimality"
    _property_names[options_filename] = "options_filename"
    _property_names[allow_internal_primal_infeasibility_measure_normalization] = "allow_internal_primal_infeasibility_measure_normalization"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileSNOPTOptimizer."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileSNOPTOptimizer)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileSNOPTOptimizer, [ProfileSNOPTOptimizer, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5284407112942418573, 3368784081012521918), ProfileSNOPTOptimizer)
agcls.AgTypeNameMap["ProfileSNOPTOptimizer"] = ProfileSNOPTOptimizer

class SNOPTControl(SupportsDeleteCallback):
    """Properties for control parameters of a SNOPT profile."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_initial_value_method_offset = 5
    _get_current_value_method_offset = 6
    _set_current_value_method_offset = 7
    _get_lower_bound_method_offset = 8
    _set_lower_bound_method_offset = 9
    _get_upper_bound_method_offset = 10
    _set_upper_bound_method_offset = 11
    _get_scaling_value_method_offset = 12
    _set_scaling_value_method_offset = 13
    _get_use_custom_display_unit_method_offset = 14
    _set_use_custom_display_unit_method_offset = 15
    _get_custom_display_unit_method_offset = 16
    _set_custom_display_unit_method_offset = 17
    _metadata = {
        "iid_data" : (4762704521604592018, 2371064697729832603),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SNOPTControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_parent_name_metadata)

    _get_initial_value_metadata = { "offset" : _get_initial_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_value(self) -> typing.Any:
        """Get the nominal value of the element selected as a parameter. Dimension depends on context."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_initial_value_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get or set the value of the independent variable after the last targeter run."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_current_value_metadata)

    _set_current_value_metadata = { "offset" : _set_current_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @current_value.setter
    def current_value(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_current_value_metadata, value)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_upper_bound_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_scaling_value_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(SNOPTControl._metadata, SNOPTControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(SNOPTControl._metadata, SNOPTControl._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[initial_value] = "initial_value"
    _property_names[current_value] = "current_value"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[scaling_value] = "scaling_value"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type SNOPTControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SNOPTControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SNOPTControl, [SNOPTControl, ])

agcls.AgClassCatalog.add_catalog_entry((5571950865244808171, 10821277464681537955), SNOPTControl)
agcls.AgTypeNameMap["SNOPTControl"] = SNOPTControl

class SNOPTResult(SupportsDeleteCallback):
    """Properties for objecvtive and constraints of a SNOPT profile."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_current_value_method_offset = 4
    _get_parent_name_method_offset = 5
    _get_lower_bound_method_offset = 6
    _set_lower_bound_method_offset = 7
    _get_upper_bound_method_offset = 8
    _set_upper_bound_method_offset = 9
    _get_scaling_value_method_offset = 10
    _set_scaling_value_method_offset = 11
    _get_weight_method_offset = 12
    _set_weight_method_offset = 13
    _get_goal_method_offset = 14
    _set_goal_method_offset = 15
    _get_use_custom_display_unit_method_offset = 16
    _set_use_custom_display_unit_method_offset = 17
    _get_custom_display_unit_method_offset = 18
    _set_custom_display_unit_method_offset = 19
    _metadata = {
        "iid_data" : (4901011265381019165, 12207151560770997405),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SNOPTResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value achieved for this dependent variable in the last targeter run. Dimension depends on context."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_current_value_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Object - the name of the segment to which the parameter belongs."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_parent_name_metadata)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Get or set the lower limit achievable by this quantity in the optimizer's iteration history. Dimension depends on context."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Get or set the upper limit achievable by this quantity in the optimizer's iteration history. Dimension depends on context."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_upper_bound_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_scaling_value_metadata, value)

    _get_weight_metadata = { "offset" : _get_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def weight(self) -> float:
        """Get or set the factor by which the constraint error is to be multiplied."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_weight_metadata)

    _set_weight_metadata = { "offset" : _set_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @weight.setter
    def weight(self, value:float) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_weight_metadata, value)

    _get_goal_metadata = { "offset" : _get_goal_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SNOPTGoal),) }
    @property
    def goal(self) -> "SNOPTGoal":
        """Get or set the purpose of the element in the problem."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_goal_metadata)

    _set_goal_metadata = { "offset" : _set_goal_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SNOPTGoal),) }
    @goal.setter
    def goal(self, value:"SNOPTGoal") -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_goal_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(SNOPTResult._metadata, SNOPTResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(SNOPTResult._metadata, SNOPTResult._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[current_value] = "current_value"
    _property_names[parent_name] = "parent_name"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[scaling_value] = "scaling_value"
    _property_names[weight] = "weight"
    _property_names[goal] = "goal"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type SNOPTResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SNOPTResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SNOPTResult, [SNOPTResult, ])

agcls.AgClassCatalog.add_catalog_entry((5429352756697192284, 6147634570721065617), SNOPTResult)
agcls.AgTypeNameMap["SNOPTResult"] = SNOPTResult

class SNOPTControlCollection(SupportsDeleteCallback):
    """Properties for the list of SNOPT control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5604173860902349208, 5855630180278497942),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SNOPTControlCollection)
    def __iter__(self):
        """Create an iterator for the SNOPTControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "SNOPTControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "SNOPTControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(SNOPTControlCollection._metadata, SNOPTControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(SNOPTControlCollection._metadata, SNOPTControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(SNOPTControlCollection._metadata, SNOPTControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "SNOPTControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(SNOPTControlCollection._metadata, SNOPTControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type SNOPTControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SNOPTControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SNOPTControlCollection, [SNOPTControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5633121791954045522, 5448792849790426752), SNOPTControlCollection)
agcls.AgTypeNameMap["SNOPTControlCollection"] = SNOPTControlCollection

class SNOPTResultCollection(SupportsDeleteCallback):
    """SNOPT result collection."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5507754285275224124, 2750094358517221257),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SNOPTResultCollection)
    def __iter__(self):
        """Create an iterator for the SNOPTResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "SNOPTResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "SNOPTResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(SNOPTResultCollection._metadata, SNOPTResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(SNOPTResultCollection._metadata, SNOPTResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(SNOPTResultCollection._metadata, SNOPTResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "SNOPTResult":
        """Return the result specified by the object/result names."""
        return self._intf.invoke(SNOPTResultCollection._metadata, SNOPTResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type SNOPTResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, SNOPTResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, SNOPTResultCollection, [SNOPTResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4656791029766995763, 579569562398177441), SNOPTResultCollection)
agcls.AgTypeNameMap["SNOPTResultCollection"] = SNOPTResultCollection

class ProfileIPOPTOptimizer(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties of IPOPT Optimizer profile."""

    _num_methods = 18
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_control_parameters_method_offset = 1
    _get_results_method_offset = 2
    _get_targeter_graphs_method_offset = 3
    _get_scripting_tool_method_offset = 4
    _get_reset_controls_before_run_method_offset = 5
    _set_reset_controls_before_run_method_offset = 6
    _get_tolerance_on_convergence_method_offset = 7
    _set_tolerance_on_convergence_method_offset = 8
    _get_maximum_iterations_method_offset = 9
    _set_maximum_iterations_method_offset = 10
    _get_tolerance_on_constraint_violation_method_offset = 11
    _set_tolerance_on_constraint_violation_method_offset = 12
    _get_tolerance_on_dual_infeasibility_method_offset = 13
    _set_tolerance_on_dual_infeasibility_method_offset = 14
    _get_tolerance_on_complementary_infeasibility_method_offset = 15
    _set_tolerance_on_complementary_infeasibility_method_offset = 16
    _get_options_filename_method_offset = 17
    _set_options_filename_method_offset = 18
    _metadata = {
        "iid_data" : (4751264102437666878, 12170707282220075141),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileIPOPTOptimizer)

    _get_control_parameters_metadata = { "offset" : _get_control_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def control_parameters(self) -> "IPOPTControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_control_parameters_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "IPOPTResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_results_metadata)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_targeter_graphs_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_scripting_tool_metadata)

    _get_reset_controls_before_run_metadata = { "offset" : _get_reset_controls_before_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reset_controls_before_run(self) -> bool:
        """Reset controls before each run."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_reset_controls_before_run_metadata)

    _set_reset_controls_before_run_metadata = { "offset" : _set_reset_controls_before_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reset_controls_before_run.setter
    def reset_controls_before_run(self, value:bool) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_reset_controls_before_run_metadata, value)

    _get_tolerance_on_convergence_metadata = { "offset" : _get_tolerance_on_convergence_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_convergence(self) -> float:
        """Get or set the tolerance by which the optimality conditions must be satisfied for the problem to be considered converged. The default value is 1E-8."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_tolerance_on_convergence_metadata)

    _set_tolerance_on_convergence_metadata = { "offset" : _set_tolerance_on_convergence_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_convergence.setter
    def tolerance_on_convergence(self, value:float) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_tolerance_on_convergence_metadata, value)

    _get_maximum_iterations_metadata = { "offset" : _get_maximum_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def maximum_iterations(self) -> int:
        """Get or set the maximum number of iterations before IPOPT should give up if it hasn't yet converged on a solution. The default value is 3000."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_maximum_iterations_metadata)

    _set_maximum_iterations_metadata = { "offset" : _set_maximum_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @maximum_iterations.setter
    def maximum_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_maximum_iterations_metadata, value)

    _get_tolerance_on_constraint_violation_metadata = { "offset" : _get_tolerance_on_constraint_violation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_constraint_violation(self) -> float:
        """Get or set the tolerance by which user-specified constraints are allowed to be violated with the solution still considered feasible. The default value is 1.0E-4."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_tolerance_on_constraint_violation_metadata)

    _set_tolerance_on_constraint_violation_metadata = { "offset" : _set_tolerance_on_constraint_violation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_constraint_violation.setter
    def tolerance_on_constraint_violation(self, value:float) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_tolerance_on_constraint_violation_metadata, value)

    _get_tolerance_on_dual_infeasibility_metadata = { "offset" : _get_tolerance_on_dual_infeasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_dual_infeasibility(self) -> float:
        """Get or set the desired absolute tolerance on the maximum norm of the dual infeasibility. The default value is 1."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_tolerance_on_dual_infeasibility_metadata)

    _set_tolerance_on_dual_infeasibility_metadata = { "offset" : _set_tolerance_on_dual_infeasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_dual_infeasibility.setter
    def tolerance_on_dual_infeasibility(self, value:float) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_tolerance_on_dual_infeasibility_metadata, value)

    _get_tolerance_on_complementary_infeasibility_metadata = { "offset" : _get_tolerance_on_complementary_infeasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_complementary_infeasibility(self) -> float:
        """Get or set the desired absolute tolerance on the maximum norm of the complementarity conditions. The default value is 1.0E-4."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_tolerance_on_complementary_infeasibility_metadata)

    _set_tolerance_on_complementary_infeasibility_metadata = { "offset" : _set_tolerance_on_complementary_infeasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_complementary_infeasibility.setter
    def tolerance_on_complementary_infeasibility(self, value:float) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_tolerance_on_complementary_infeasibility_metadata, value)

    _get_options_filename_metadata = { "offset" : _get_options_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def options_filename(self) -> str:
        """If used, the associated IPOPT specifications file may define any of the various IPOPT options. Options in the file that conflict with options specified elsewhere will take precedence."""
        return self._intf.get_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._get_options_filename_metadata)

    _set_options_filename_metadata = { "offset" : _set_options_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @options_filename.setter
    def options_filename(self, value:str) -> None:
        return self._intf.set_property(ProfileIPOPTOptimizer._metadata, ProfileIPOPTOptimizer._set_options_filename_metadata, value)

    _property_names[control_parameters] = "control_parameters"
    _property_names[results] = "results"
    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[reset_controls_before_run] = "reset_controls_before_run"
    _property_names[tolerance_on_convergence] = "tolerance_on_convergence"
    _property_names[maximum_iterations] = "maximum_iterations"
    _property_names[tolerance_on_constraint_violation] = "tolerance_on_constraint_violation"
    _property_names[tolerance_on_dual_infeasibility] = "tolerance_on_dual_infeasibility"
    _property_names[tolerance_on_complementary_infeasibility] = "tolerance_on_complementary_infeasibility"
    _property_names[options_filename] = "options_filename"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileIPOPTOptimizer."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileIPOPTOptimizer)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileIPOPTOptimizer, [ProfileIPOPTOptimizer, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5568187666386354440, 8632403443185718923), ProfileIPOPTOptimizer)
agcls.AgTypeNameMap["ProfileIPOPTOptimizer"] = ProfileIPOPTOptimizer

class IPOPTControl(SupportsDeleteCallback):
    """Properties for control parameters of a IPOPT profile."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_initial_value_method_offset = 5
    _get_current_value_method_offset = 6
    _set_current_value_method_offset = 7
    _get_lower_bound_method_offset = 8
    _set_lower_bound_method_offset = 9
    _get_upper_bound_method_offset = 10
    _set_upper_bound_method_offset = 11
    _get_scaling_value_method_offset = 12
    _set_scaling_value_method_offset = 13
    _get_use_custom_display_unit_method_offset = 14
    _set_use_custom_display_unit_method_offset = 15
    _get_custom_display_unit_method_offset = 16
    _set_custom_display_unit_method_offset = 17
    _metadata = {
        "iid_data" : (5150148644969543295, 6124481234419825067),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, IPOPTControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_parent_name_metadata)

    _get_initial_value_metadata = { "offset" : _get_initial_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_value(self) -> typing.Any:
        """Get the nominal value of the element selected as a parameter. Dimension depends on context."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_initial_value_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get or set the value of the independent variable after the last targeter run."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_current_value_metadata)

    _set_current_value_metadata = { "offset" : _set_current_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @current_value.setter
    def current_value(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_current_value_metadata, value)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_upper_bound_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_scaling_value_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(IPOPTControl._metadata, IPOPTControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(IPOPTControl._metadata, IPOPTControl._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[initial_value] = "initial_value"
    _property_names[current_value] = "current_value"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[scaling_value] = "scaling_value"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type IPOPTControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, IPOPTControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, IPOPTControl, [IPOPTControl, ])

agcls.AgClassCatalog.add_catalog_entry((5415810020451243738, 18234088207928978568), IPOPTControl)
agcls.AgTypeNameMap["IPOPTControl"] = IPOPTControl

class IPOPTResult(SupportsDeleteCallback):
    """Properties for objecvtive and constraints of a IPOPT profile."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_current_value_method_offset = 4
    _get_parent_name_method_offset = 5
    _get_lower_bound_method_offset = 6
    _set_lower_bound_method_offset = 7
    _get_upper_bound_method_offset = 8
    _set_upper_bound_method_offset = 9
    _get_scaling_value_method_offset = 10
    _set_scaling_value_method_offset = 11
    _get_weight_method_offset = 12
    _set_weight_method_offset = 13
    _get_goal_method_offset = 14
    _set_goal_method_offset = 15
    _get_use_custom_display_unit_method_offset = 16
    _set_use_custom_display_unit_method_offset = 17
    _get_custom_display_unit_method_offset = 18
    _set_custom_display_unit_method_offset = 19
    _metadata = {
        "iid_data" : (4762668939937227037, 15340309722893180073),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, IPOPTResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value achieved for this dependent variable in the last targeter run. Dimension depends on context."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_current_value_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Object - the name of the segment to which the parameter belongs."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_parent_name_metadata)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Get or set the lower limit achievable by this quantity in the optimizer's iteration history. Dimension depends on context."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Get or set the upper limit achievable by this quantity in the optimizer's iteration history. Dimension depends on context."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_upper_bound_metadata, value)

    _get_scaling_value_metadata = { "offset" : _get_scaling_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def scaling_value(self) -> typing.Any:
        """Apply to the Specified Value scaling method. Dimension depends on context."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_scaling_value_metadata)

    _set_scaling_value_metadata = { "offset" : _set_scaling_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @scaling_value.setter
    def scaling_value(self, value:typing.Any) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_scaling_value_metadata, value)

    _get_weight_metadata = { "offset" : _get_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def weight(self) -> float:
        """Get or set the factor by which the constraint error is to be multiplied."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_weight_metadata)

    _set_weight_metadata = { "offset" : _set_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @weight.setter
    def weight(self, value:float) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_weight_metadata, value)

    _get_goal_metadata = { "offset" : _get_goal_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(IPOPTGoal),) }
    @property
    def goal(self) -> "IPOPTGoal":
        """Get or set the purpose of the element in the problem."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_goal_metadata)

    _set_goal_metadata = { "offset" : _set_goal_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(IPOPTGoal),) }
    @goal.setter
    def goal(self, value:"IPOPTGoal") -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_goal_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(IPOPTResult._metadata, IPOPTResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(IPOPTResult._metadata, IPOPTResult._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[current_value] = "current_value"
    _property_names[parent_name] = "parent_name"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[scaling_value] = "scaling_value"
    _property_names[weight] = "weight"
    _property_names[goal] = "goal"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type IPOPTResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, IPOPTResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, IPOPTResult, [IPOPTResult, ])

agcls.AgClassCatalog.add_catalog_entry((5749859566825051606, 3700808484372834489), IPOPTResult)
agcls.AgTypeNameMap["IPOPTResult"] = IPOPTResult

class IPOPTControlCollection(SupportsDeleteCallback):
    """Properties for the list of IPOPT control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5371619775496741938, 13477957420178317993),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, IPOPTControlCollection)
    def __iter__(self):
        """Create an iterator for the IPOPTControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IPOPTControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "IPOPTControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(IPOPTControlCollection._metadata, IPOPTControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(IPOPTControlCollection._metadata, IPOPTControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(IPOPTControlCollection._metadata, IPOPTControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "IPOPTControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(IPOPTControlCollection._metadata, IPOPTControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type IPOPTControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, IPOPTControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, IPOPTControlCollection, [IPOPTControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4683303804897886652, 10183995070423025552), IPOPTControlCollection)
agcls.AgTypeNameMap["IPOPTControlCollection"] = IPOPTControlCollection

class IPOPTResultCollection(SupportsDeleteCallback):
    """IPOPT result collection."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5596307863142992893, 15167583734049716609),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, IPOPTResultCollection)
    def __iter__(self):
        """Create an iterator for the IPOPTResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IPOPTResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "IPOPTResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(IPOPTResultCollection._metadata, IPOPTResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(IPOPTResultCollection._metadata, IPOPTResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(IPOPTResultCollection._metadata, IPOPTResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "IPOPTResult":
        """Return the result specified by the object/result names."""
        return self._intf.invoke(IPOPTResultCollection._metadata, IPOPTResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type IPOPTResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, IPOPTResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, IPOPTResultCollection, [IPOPTResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4859533124734869945, 6672937630293285034), IPOPTResultCollection)
agcls.AgTypeNameMap["IPOPTResultCollection"] = IPOPTResultCollection

class ManeuverOptimalFinite(IManeuver, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Engine properties for a Optimal Finite Maneuver."""

    _num_methods = 40
    _vtable_offset = IManeuver._vtable_offset + IManeuver._num_methods
    _get_pressure_mode_method_offset = 1
    _set_pressure_mode_method_offset = 2
    _get_thrust_efficiency_method_offset = 3
    _set_thrust_efficiency_method_offset = 4
    _get_thrust_efficiency_mode_method_offset = 5
    _set_thrust_efficiency_mode_method_offset = 6
    _get_number_of_nodes_method_offset = 7
    _set_number_of_nodes_method_offset = 8
    _get_initial_guess_file_name_method_offset = 9
    _set_initial_guess_file_name_method_offset = 10
    _get_seed_method_method_offset = 11
    _set_seed_method_method_offset = 12
    _run_seed_method_offset = 13
    _get_node_status_message_method_offset = 14
    _get_run_mode_method_offset = 15
    _set_run_mode_method_offset = 16
    _get_halt_mission_control_sequence_for_nonconvergence_method_offset = 17
    _set_halt_mission_control_sequence_for_nonconvergence_method_offset = 18
    _get_discretization_strategy_method_offset = 19
    _set_discretization_strategy_method_offset = 20
    _get_working_variables_method_offset = 21
    _set_working_variables_method_offset = 22
    _get_scaling_options_method_offset = 23
    _set_scaling_options_method_offset = 24
    _get_enable_unit_vector_controls_method_offset = 25
    _set_enable_unit_vector_controls_method_offset = 26
    _get_thrust_axes_method_offset = 27
    _get_snopt_optimizer_method_offset = 28
    _get_initial_boundary_conditions_method_offset = 29
    _get_final_boundary_conditions_method_offset = 30
    _get_path_boundary_conditions_method_offset = 31
    _get_log_file_name_method_offset = 32
    _get_export_format_method_offset = 33
    _set_export_format_method_offset = 34
    _get_steering_nodes_method_offset = 35
    _export_nodes_method_offset = 36
    _get_initial_guess_interpolation_method_method_offset = 37
    _set_initial_guess_interpolation_method_method_offset = 38
    _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 39
    _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset = 40
    _metadata = {
        "iid_data" : (5286881738049363473, 1389375119741404061),
        "vtable_reference" : IManeuver._vtable_offset + IManeuver._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFinite)

    _get_pressure_mode_metadata = { "offset" : _get_pressure_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PressureMode),) }
    @property
    def pressure_mode(self) -> "PressureMode":
        """Get or set the pressure mode."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_pressure_mode_metadata)

    _set_pressure_mode_metadata = { "offset" : _set_pressure_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PressureMode),) }
    @pressure_mode.setter
    def pressure_mode(self, value:"PressureMode") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_pressure_mode_metadata, value)

    _get_thrust_efficiency_metadata = { "offset" : _get_thrust_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def thrust_efficiency(self) -> float:
        """Get or set the fraction of ideal thrust applied. Any number above zero is valid, with typical values around 0.98 to 1.02. Dimensionless."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_thrust_efficiency_metadata)

    _set_thrust_efficiency_metadata = { "offset" : _set_thrust_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @thrust_efficiency.setter
    def thrust_efficiency(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_thrust_efficiency_metadata, value)

    _get_thrust_efficiency_mode_metadata = { "offset" : _get_thrust_efficiency_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ThrustType),) }
    @property
    def thrust_efficiency_mode(self) -> "ThrustType":
        """Thrust - the calculations that are effected by the thrust efficiency value."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_thrust_efficiency_mode_metadata)

    _set_thrust_efficiency_mode_metadata = { "offset" : _set_thrust_efficiency_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ThrustType),) }
    @thrust_efficiency_mode.setter
    def thrust_efficiency_mode(self, value:"ThrustType") -> None:
        """Mode indicating fraction of ideal thrust applied."""
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_thrust_efficiency_mode_metadata, value)

    _get_number_of_nodes_metadata = { "offset" : _get_number_of_nodes_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def number_of_nodes(self) -> int:
        """Number of nodes to discretize collocation problem into."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_number_of_nodes_metadata)

    _set_number_of_nodes_metadata = { "offset" : _set_number_of_nodes_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @number_of_nodes.setter
    def number_of_nodes(self, value:int) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_number_of_nodes_metadata, value)

    _get_initial_guess_file_name_metadata = { "offset" : _get_initial_guess_file_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def initial_guess_file_name(self) -> str:
        """File containing ephemeris for nodes that serve as an initial guess."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_initial_guess_file_name_metadata)

    _set_initial_guess_file_name_metadata = { "offset" : _set_initial_guess_file_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @initial_guess_file_name.setter
    def initial_guess_file_name(self, value:str) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_initial_guess_file_name_metadata, value)

    _get_seed_method_metadata = { "offset" : _get_seed_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSeedMethod),) }
    @property
    def seed_method(self) -> "OptimalFiniteSeedMethod":
        """Initial seed method."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_seed_method_metadata)

    _set_seed_method_metadata = { "offset" : _set_seed_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSeedMethod),) }
    @seed_method.setter
    def seed_method(self, value:"OptimalFiniteSeedMethod") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_seed_method_metadata, value)

    _run_seed_metadata = { "offset" : _run_seed_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def run_seed(self) -> None:
        """Run seed."""
        return self._intf.invoke(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._run_seed_metadata, )

    _get_node_status_message_metadata = { "offset" : _get_node_status_message_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def node_status_message(self) -> str:
        """A message that indicates what nodes are currently held by the segment."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_node_status_message_metadata)

    _get_run_mode_metadata = { "offset" : _get_run_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteRunMode),) }
    @property
    def run_mode(self) -> "OptimalFiniteRunMode":
        """Run mode."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_run_mode_metadata)

    _set_run_mode_metadata = { "offset" : _set_run_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteRunMode),) }
    @run_mode.setter
    def run_mode(self, value:"OptimalFiniteRunMode") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_run_mode_metadata, value)

    _get_halt_mission_control_sequence_for_nonconvergence_metadata = { "offset" : _get_halt_mission_control_sequence_for_nonconvergence_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def halt_mission_control_sequence_for_nonconvergence(self) -> bool:
        """Halt MCS and discard result if optimization is unsuccessful."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_halt_mission_control_sequence_for_nonconvergence_metadata)

    _set_halt_mission_control_sequence_for_nonconvergence_metadata = { "offset" : _set_halt_mission_control_sequence_for_nonconvergence_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @halt_mission_control_sequence_for_nonconvergence.setter
    def halt_mission_control_sequence_for_nonconvergence(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_halt_mission_control_sequence_for_nonconvergence_metadata, value)

    _get_discretization_strategy_metadata = { "offset" : _get_discretization_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteDiscretizationStrategy),) }
    @property
    def discretization_strategy(self) -> "OptimalFiniteDiscretizationStrategy":
        """Discretization Strategy."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_discretization_strategy_metadata)

    _set_discretization_strategy_metadata = { "offset" : _set_discretization_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteDiscretizationStrategy),) }
    @discretization_strategy.setter
    def discretization_strategy(self, value:"OptimalFiniteDiscretizationStrategy") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_discretization_strategy_metadata, value)

    _get_working_variables_metadata = { "offset" : _get_working_variables_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteWorkingVariables),) }
    @property
    def working_variables(self) -> "OptimalFiniteWorkingVariables":
        """Working Variables."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_working_variables_metadata)

    _set_working_variables_metadata = { "offset" : _set_working_variables_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteWorkingVariables),) }
    @working_variables.setter
    def working_variables(self, value:"OptimalFiniteWorkingVariables") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_working_variables_metadata, value)

    _get_scaling_options_metadata = { "offset" : _get_scaling_options_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteScalingOptions),) }
    @property
    def scaling_options(self) -> "OptimalFiniteScalingOptions":
        """Scaling Options."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_scaling_options_metadata)

    _set_scaling_options_metadata = { "offset" : _set_scaling_options_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteScalingOptions),) }
    @scaling_options.setter
    def scaling_options(self, value:"OptimalFiniteScalingOptions") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_scaling_options_metadata, value)

    _get_enable_unit_vector_controls_metadata = { "offset" : _get_enable_unit_vector_controls_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_unit_vector_controls(self) -> bool:
        """Enable unit vector for thrust direction."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_enable_unit_vector_controls_metadata)

    _set_enable_unit_vector_controls_metadata = { "offset" : _set_enable_unit_vector_controls_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_unit_vector_controls.setter
    def enable_unit_vector_controls(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_enable_unit_vector_controls_metadata, value)

    _get_thrust_axes_metadata = { "offset" : _get_thrust_axes_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def thrust_axes(self) -> str:
        """Label reflecting coordinate axes for the thrust vector."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_thrust_axes_metadata)

    _get_snopt_optimizer_metadata = { "offset" : _get_snopt_optimizer_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def snopt_optimizer(self) -> "ManeuverOptimalFiniteSNOPTOptimizer":
        """SNOPT Optimizer Options."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_snopt_optimizer_metadata)

    _get_initial_boundary_conditions_metadata = { "offset" : _get_initial_boundary_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def initial_boundary_conditions(self) -> "ManeuverOptimalFiniteInitialBoundaryConditions":
        """Initial Boundary Conditions."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_initial_boundary_conditions_metadata)

    _get_final_boundary_conditions_metadata = { "offset" : _get_final_boundary_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def final_boundary_conditions(self) -> "ManeuverOptimalFiniteFinalBoundaryConditions":
        """Final Boundary Conditions."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_final_boundary_conditions_metadata)

    _get_path_boundary_conditions_metadata = { "offset" : _get_path_boundary_conditions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def path_boundary_conditions(self) -> "ManeuverOptimalFinitePathBoundaryConditions":
        """Path Boundary Conditions."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_path_boundary_conditions_metadata)

    _get_log_file_name_metadata = { "offset" : _get_log_file_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def log_file_name(self) -> str:
        """Log file name for optimal finite maneuver."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_log_file_name_metadata)

    _get_export_format_metadata = { "offset" : _get_export_format_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteExportNodesFormat),) }
    @property
    def export_format(self) -> "OptimalFiniteExportNodesFormat":
        """Format for exporting collocation control variables."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_export_format_metadata)

    _set_export_format_metadata = { "offset" : _set_export_format_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteExportNodesFormat),) }
    @export_format.setter
    def export_format(self, value:"OptimalFiniteExportNodesFormat") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_export_format_metadata, value)

    _get_steering_nodes_metadata = { "offset" : _get_steering_nodes_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def steering_nodes(self) -> "ManeuverOptimalFiniteSteeringNodeCollection":
        """Get the list of steering nodes."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_steering_nodes_metadata)

    _export_nodes_metadata = { "offset" : _export_nodes_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def export_nodes(self, file_name:str) -> None:
        """Export the current set of collocation nodes to a file."""
        return self._intf.invoke(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._export_nodes_metadata, file_name)

    _get_initial_guess_interpolation_method_metadata = { "offset" : _get_initial_guess_interpolation_method_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteGuessMethod),) }
    @property
    def initial_guess_interpolation_method(self) -> "OptimalFiniteGuessMethod":
        """Guess interpolation method."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_initial_guess_interpolation_method_metadata)

    _set_initial_guess_interpolation_method_metadata = { "offset" : _set_initial_guess_interpolation_method_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteGuessMethod),) }
    @initial_guess_interpolation_method.setter
    def initial_guess_interpolation_method(self, value:"OptimalFiniteGuessMethod") -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_initial_guess_interpolation_method_metadata, value)

    _get_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _get_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_reinitialize_stm_at_start_of_segment_propagation(self) -> bool:
        """If this segment is propagating the state transition matrix, reset it to the identity matrix at the start of the segment."""
        return self._intf.get_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._get_should_reinitialize_stm_at_start_of_segment_propagation_metadata)

    _set_should_reinitialize_stm_at_start_of_segment_propagation_metadata = { "offset" : _set_should_reinitialize_stm_at_start_of_segment_propagation_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_reinitialize_stm_at_start_of_segment_propagation.setter
    def should_reinitialize_stm_at_start_of_segment_propagation(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFinite._metadata, ManeuverOptimalFinite._set_should_reinitialize_stm_at_start_of_segment_propagation_metadata, value)

    _property_names[pressure_mode] = "pressure_mode"
    _property_names[thrust_efficiency] = "thrust_efficiency"
    _property_names[thrust_efficiency_mode] = "thrust_efficiency_mode"
    _property_names[number_of_nodes] = "number_of_nodes"
    _property_names[initial_guess_file_name] = "initial_guess_file_name"
    _property_names[seed_method] = "seed_method"
    _property_names[node_status_message] = "node_status_message"
    _property_names[run_mode] = "run_mode"
    _property_names[halt_mission_control_sequence_for_nonconvergence] = "halt_mission_control_sequence_for_nonconvergence"
    _property_names[discretization_strategy] = "discretization_strategy"
    _property_names[working_variables] = "working_variables"
    _property_names[scaling_options] = "scaling_options"
    _property_names[enable_unit_vector_controls] = "enable_unit_vector_controls"
    _property_names[thrust_axes] = "thrust_axes"
    _property_names[snopt_optimizer] = "snopt_optimizer"
    _property_names[initial_boundary_conditions] = "initial_boundary_conditions"
    _property_names[final_boundary_conditions] = "final_boundary_conditions"
    _property_names[path_boundary_conditions] = "path_boundary_conditions"
    _property_names[log_file_name] = "log_file_name"
    _property_names[export_format] = "export_format"
    _property_names[steering_nodes] = "steering_nodes"
    _property_names[initial_guess_interpolation_method] = "initial_guess_interpolation_method"
    _property_names[should_reinitialize_stm_at_start_of_segment_propagation] = "should_reinitialize_stm_at_start_of_segment_propagation"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFinite."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFinite)
        IManeuver.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IManeuver._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFinite, [ManeuverOptimalFinite, IManeuver, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4783707281485617471, 8884688168498554016), ManeuverOptimalFinite)
agcls.AgTypeNameMap["ManeuverOptimalFinite"] = ManeuverOptimalFinite

class ManeuverOptimalFiniteSNOPTOptimizer(SupportsDeleteCallback):
    """Properties of SNOPT Optimizer options for optimal finite maneuver."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_objective_method_offset = 1
    _set_objective_method_offset = 2
    _get_max_major_iterations_method_offset = 3
    _set_max_major_iterations_method_offset = 4
    _get_tolerance_on_major_feasibility_method_offset = 5
    _set_tolerance_on_major_feasibility_method_offset = 6
    _get_tolerance_on_major_optimality_method_offset = 7
    _set_tolerance_on_major_optimality_method_offset = 8
    _get_max_minor_iterations_method_offset = 9
    _set_max_minor_iterations_method_offset = 10
    _get_tolerance_on_minor_feasibility_method_offset = 11
    _set_tolerance_on_minor_feasibility_method_offset = 12
    _get_options_filename_method_offset = 13
    _set_options_filename_method_offset = 14
    _get_provide_runtime_type_info_method_offset = 15
    _get_use_console_monitor_method_offset = 16
    _set_use_console_monitor_method_offset = 17
    _get_allow_internal_primal_infeasibility_measure_normalization_method_offset = 18
    _set_allow_internal_primal_infeasibility_measure_normalization_method_offset = 19
    _get_snopt_scaling_method_offset = 20
    _set_snopt_scaling_method_offset = 21
    _metadata = {
        "iid_data" : (4996902975628294078, 18237553613899441294),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteSNOPTOptimizer)

    _get_objective_metadata = { "offset" : _get_objective_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSNOPTObjective),) }
    @property
    def objective(self) -> "OptimalFiniteSNOPTObjective":
        """Objective."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_objective_metadata)

    _set_objective_metadata = { "offset" : _set_objective_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSNOPTObjective),) }
    @objective.setter
    def objective(self, value:"OptimalFiniteSNOPTObjective") -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_objective_metadata, value)

    _get_max_major_iterations_metadata = { "offset" : _get_max_major_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_major_iterations(self) -> int:
        """Get or set the maximum number of major iterations allowed."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_max_major_iterations_metadata)

    _set_max_major_iterations_metadata = { "offset" : _set_max_major_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_major_iterations.setter
    def max_major_iterations(self, value:int) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_max_major_iterations_metadata, value)

    _get_tolerance_on_major_feasibility_metadata = { "offset" : _get_tolerance_on_major_feasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_major_feasibility(self) -> float:
        """Specify how accurately the nonlinear constraints should be satisfied."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_tolerance_on_major_feasibility_metadata)

    _set_tolerance_on_major_feasibility_metadata = { "offset" : _set_tolerance_on_major_feasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_major_feasibility.setter
    def tolerance_on_major_feasibility(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_tolerance_on_major_feasibility_metadata, value)

    _get_tolerance_on_major_optimality_metadata = { "offset" : _get_tolerance_on_major_optimality_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_major_optimality(self) -> float:
        """Specify the final accuracy of the dual variables."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_tolerance_on_major_optimality_metadata)

    _set_tolerance_on_major_optimality_metadata = { "offset" : _set_tolerance_on_major_optimality_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_major_optimality.setter
    def tolerance_on_major_optimality(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_tolerance_on_major_optimality_metadata, value)

    _get_max_minor_iterations_metadata = { "offset" : _get_max_minor_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_minor_iterations(self) -> int:
        """Get or set the maximum number of iterations for the QP subproblem allowed during a single major iteration."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_max_minor_iterations_metadata)

    _set_max_minor_iterations_metadata = { "offset" : _set_max_minor_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_minor_iterations.setter
    def max_minor_iterations(self, value:int) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_max_minor_iterations_metadata, value)

    _get_tolerance_on_minor_feasibility_metadata = { "offset" : _get_tolerance_on_minor_feasibility_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tolerance_on_minor_feasibility(self) -> float:
        """Get or set the tolerance which the QP subproblem must meet before being considered feasible."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_tolerance_on_minor_feasibility_metadata)

    _set_tolerance_on_minor_feasibility_metadata = { "offset" : _set_tolerance_on_minor_feasibility_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tolerance_on_minor_feasibility.setter
    def tolerance_on_minor_feasibility(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_tolerance_on_minor_feasibility_metadata, value)

    _get_options_filename_metadata = { "offset" : _get_options_filename_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def options_filename(self) -> str:
        """If used, the associated SNOPT specifications file may define any of the various SNOPT options. Options in the file that conflict with options specified elsewhere will take precedence."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_options_filename_metadata)

    _set_options_filename_metadata = { "offset" : _set_options_filename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @options_filename.setter
    def options_filename(self, value:str) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_options_filename_metadata, value)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_provide_runtime_type_info_metadata)

    _get_use_console_monitor_metadata = { "offset" : _get_use_console_monitor_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_console_monitor(self) -> bool:
        """Whether to use the out-of-process console monitor for the optimizer."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_use_console_monitor_metadata)

    _set_use_console_monitor_metadata = { "offset" : _set_use_console_monitor_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_console_monitor.setter
    def use_console_monitor(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_use_console_monitor_metadata, value)

    _get_allow_internal_primal_infeasibility_measure_normalization_metadata = { "offset" : _get_allow_internal_primal_infeasibility_measure_normalization_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def allow_internal_primal_infeasibility_measure_normalization(self) -> bool:
        """Whether to allow internal normalization of the primal infeasibility measure."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_allow_internal_primal_infeasibility_measure_normalization_metadata)

    _set_allow_internal_primal_infeasibility_measure_normalization_metadata = { "offset" : _set_allow_internal_primal_infeasibility_measure_normalization_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @allow_internal_primal_infeasibility_measure_normalization.setter
    def allow_internal_primal_infeasibility_measure_normalization(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_allow_internal_primal_infeasibility_measure_normalization_metadata, value)

    _get_snopt_scaling_metadata = { "offset" : _get_snopt_scaling_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSNOPTScaling),) }
    @property
    def snopt_scaling(self) -> "OptimalFiniteSNOPTScaling":
        """SNOPT scaling option."""
        return self._intf.get_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._get_snopt_scaling_metadata)

    _set_snopt_scaling_metadata = { "offset" : _set_snopt_scaling_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(OptimalFiniteSNOPTScaling),) }
    @snopt_scaling.setter
    def snopt_scaling(self, value:"OptimalFiniteSNOPTScaling") -> None:
        return self._intf.set_property(ManeuverOptimalFiniteSNOPTOptimizer._metadata, ManeuverOptimalFiniteSNOPTOptimizer._set_snopt_scaling_metadata, value)

    _property_names[objective] = "objective"
    _property_names[max_major_iterations] = "max_major_iterations"
    _property_names[tolerance_on_major_feasibility] = "tolerance_on_major_feasibility"
    _property_names[tolerance_on_major_optimality] = "tolerance_on_major_optimality"
    _property_names[max_minor_iterations] = "max_minor_iterations"
    _property_names[tolerance_on_minor_feasibility] = "tolerance_on_minor_feasibility"
    _property_names[options_filename] = "options_filename"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"
    _property_names[use_console_monitor] = "use_console_monitor"
    _property_names[allow_internal_primal_infeasibility_measure_normalization] = "allow_internal_primal_infeasibility_measure_normalization"
    _property_names[snopt_scaling] = "snopt_scaling"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteSNOPTOptimizer."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteSNOPTOptimizer)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteSNOPTOptimizer, [ManeuverOptimalFiniteSNOPTOptimizer, ])

agcls.AgClassCatalog.add_catalog_entry((5483625747432348382, 14294427433302231435), ManeuverOptimalFiniteSNOPTOptimizer)
agcls.AgTypeNameMap["ManeuverOptimalFiniteSNOPTOptimizer"] = ManeuverOptimalFiniteSNOPTOptimizer

class ManeuverOptimalFiniteInitialBoundaryConditions(SupportsDeleteCallback):
    """Properties of initial boundary conditions for optimal finite maneuver."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_set_from_initial_guess_method_offset = 1
    _set_set_from_initial_guess_method_offset = 2
    _get_a_method_offset = 3
    _get_h_method_offset = 4
    _get_k_method_offset = 5
    _get_p_method_offset = 6
    _get_q_method_offset = 7
    _get_l_method_offset = 8
    _get_provide_runtime_type_info_method_offset = 9
    _metadata = {
        "iid_data" : (5320001354157658271, 816071206625377690),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteInitialBoundaryConditions)

    _get_set_from_initial_guess_metadata = { "offset" : _get_set_from_initial_guess_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def set_from_initial_guess(self) -> bool:
        """Set initial boundary conditions from initial guess."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_set_from_initial_guess_metadata)

    _set_set_from_initial_guess_metadata = { "offset" : _set_set_from_initial_guess_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @set_from_initial_guess.setter
    def set_from_initial_guess(self, value:bool) -> None:
        """Set initial boundary conditions from initial guess."""
        return self._intf.set_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._set_set_from_initial_guess_metadata, value)

    _get_a_metadata = { "offset" : _get_a_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def a(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element a."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_a_metadata)

    _get_h_metadata = { "offset" : _get_h_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def h(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element h."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_h_metadata)

    _get_k_metadata = { "offset" : _get_k_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def k(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element k."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_k_metadata)

    _get_p_metadata = { "offset" : _get_p_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def p(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element p."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_p_metadata)

    _get_q_metadata = { "offset" : _get_q_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def q(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element q."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_q_metadata)

    _get_l_metadata = { "offset" : _get_l_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def l(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element L."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_l_metadata)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ManeuverOptimalFiniteInitialBoundaryConditions._metadata, ManeuverOptimalFiniteInitialBoundaryConditions._get_provide_runtime_type_info_metadata)

    _property_names[set_from_initial_guess] = "set_from_initial_guess"
    _property_names[a] = "a"
    _property_names[h] = "h"
    _property_names[k] = "k"
    _property_names[p] = "p"
    _property_names[q] = "q"
    _property_names[l] = "l"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteInitialBoundaryConditions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteInitialBoundaryConditions)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteInitialBoundaryConditions, [ManeuverOptimalFiniteInitialBoundaryConditions, ])

agcls.AgClassCatalog.add_catalog_entry((5403990726835451340, 7745594952569886897), ManeuverOptimalFiniteInitialBoundaryConditions)
agcls.AgTypeNameMap["ManeuverOptimalFiniteInitialBoundaryConditions"] = ManeuverOptimalFiniteInitialBoundaryConditions

class ManeuverOptimalFiniteFinalBoundaryConditions(SupportsDeleteCallback):
    """Properties of final boundary conditions for optimal finite maneuver."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_set_from_final_guess_method_offset = 1
    _set_set_from_final_guess_method_offset = 2
    _get_a_method_offset = 3
    _get_h_method_offset = 4
    _get_k_method_offset = 5
    _get_p_method_offset = 6
    _get_q_method_offset = 7
    _get_l_method_offset = 8
    _get_lower_delta_final_time_method_offset = 9
    _set_lower_delta_final_time_method_offset = 10
    _get_upper_delta_final_time_method_offset = 11
    _set_upper_delta_final_time_method_offset = 12
    _get_provide_runtime_type_info_method_offset = 13
    _metadata = {
        "iid_data" : (5608962754148717072, 2139911199912873131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteFinalBoundaryConditions)

    _get_set_from_final_guess_metadata = { "offset" : _get_set_from_final_guess_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def set_from_final_guess(self) -> bool:
        """Set initial boundary conditions from initial guess."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_set_from_final_guess_metadata)

    _set_set_from_final_guess_metadata = { "offset" : _set_set_from_final_guess_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @set_from_final_guess.setter
    def set_from_final_guess(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._set_set_from_final_guess_metadata, value)

    _get_a_metadata = { "offset" : _get_a_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def a(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element a."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_a_metadata)

    _get_h_metadata = { "offset" : _get_h_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def h(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element h."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_h_metadata)

    _get_k_metadata = { "offset" : _get_k_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def k(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element k."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_k_metadata)

    _get_p_metadata = { "offset" : _get_p_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def p(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element p."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_p_metadata)

    _get_q_metadata = { "offset" : _get_q_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def q(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element q."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_q_metadata)

    _get_l_metadata = { "offset" : _get_l_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def l(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element L."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_l_metadata)

    _get_lower_delta_final_time_metadata = { "offset" : _get_lower_delta_final_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lower_delta_final_time(self) -> float:
        """Lower delta for final time."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_lower_delta_final_time_metadata)

    _set_lower_delta_final_time_metadata = { "offset" : _set_lower_delta_final_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lower_delta_final_time.setter
    def lower_delta_final_time(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._set_lower_delta_final_time_metadata, value)

    _get_upper_delta_final_time_metadata = { "offset" : _get_upper_delta_final_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def upper_delta_final_time(self) -> float:
        """Upper delta for final time."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_upper_delta_final_time_metadata)

    _set_upper_delta_final_time_metadata = { "offset" : _set_upper_delta_final_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @upper_delta_final_time.setter
    def upper_delta_final_time(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._set_upper_delta_final_time_metadata, value)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ManeuverOptimalFiniteFinalBoundaryConditions._metadata, ManeuverOptimalFiniteFinalBoundaryConditions._get_provide_runtime_type_info_metadata)

    _property_names[set_from_final_guess] = "set_from_final_guess"
    _property_names[a] = "a"
    _property_names[h] = "h"
    _property_names[k] = "k"
    _property_names[p] = "p"
    _property_names[q] = "q"
    _property_names[l] = "l"
    _property_names[lower_delta_final_time] = "lower_delta_final_time"
    _property_names[upper_delta_final_time] = "upper_delta_final_time"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteFinalBoundaryConditions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteFinalBoundaryConditions)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteFinalBoundaryConditions, [ManeuverOptimalFiniteFinalBoundaryConditions, ])

agcls.AgClassCatalog.add_catalog_entry((4678443343641316330, 11312029768054324407), ManeuverOptimalFiniteFinalBoundaryConditions)
agcls.AgTypeNameMap["ManeuverOptimalFiniteFinalBoundaryConditions"] = ManeuverOptimalFiniteFinalBoundaryConditions

class ManeuverOptimalFinitePathBoundaryConditions(SupportsDeleteCallback):
    """Properties of path boundary conditions for optimal finite maneuver."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_compute_from_initial_guess_method_offset = 1
    _set_compute_from_initial_guess_method_offset = 2
    _get_a_method_offset = 3
    _get_h_method_offset = 4
    _get_k_method_offset = 5
    _get_p_method_offset = 6
    _get_q_method_offset = 7
    _get_l_method_offset = 8
    _get_lower_bound_azimuth_method_offset = 9
    _set_lower_bound_azimuth_method_offset = 10
    _get_upper_bound_azimuth_method_offset = 11
    _set_upper_bound_azimuth_method_offset = 12
    _get_lower_bound_elevation_method_offset = 13
    _set_lower_bound_elevation_method_offset = 14
    _get_upper_bound_elevation_method_offset = 15
    _set_upper_bound_elevation_method_offset = 16
    _get_provide_runtime_type_info_method_offset = 17
    _metadata = {
        "iid_data" : (5626545003649153510, 987668436727379598),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFinitePathBoundaryConditions)

    _get_compute_from_initial_guess_metadata = { "offset" : _get_compute_from_initial_guess_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compute_from_initial_guess(self) -> bool:
        """Compute path boundary conditions from initial guess."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_compute_from_initial_guess_metadata)

    _set_compute_from_initial_guess_metadata = { "offset" : _set_compute_from_initial_guess_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compute_from_initial_guess.setter
    def compute_from_initial_guess(self, value:bool) -> None:
        return self._intf.set_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._set_compute_from_initial_guess_metadata, value)

    _get_a_metadata = { "offset" : _get_a_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def a(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element a."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_a_metadata)

    _get_h_metadata = { "offset" : _get_h_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def h(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element h."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_h_metadata)

    _get_k_metadata = { "offset" : _get_k_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def k(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element k."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_k_metadata)

    _get_p_metadata = { "offset" : _get_p_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def p(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element p."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_p_metadata)

    _get_q_metadata = { "offset" : _get_q_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def q(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element q."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_q_metadata)

    _get_l_metadata = { "offset" : _get_l_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def l(self) -> "ManeuverOptimalFiniteBounds":
        """Bound limits for element L."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_l_metadata)

    _get_lower_bound_azimuth_metadata = { "offset" : _get_lower_bound_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lower_bound_azimuth(self) -> float:
        """Thrust direction azimuth lower bound along the path."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_lower_bound_azimuth_metadata)

    _set_lower_bound_azimuth_metadata = { "offset" : _set_lower_bound_azimuth_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lower_bound_azimuth.setter
    def lower_bound_azimuth(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._set_lower_bound_azimuth_metadata, value)

    _get_upper_bound_azimuth_metadata = { "offset" : _get_upper_bound_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def upper_bound_azimuth(self) -> float:
        """Thrust direction azimuth upper bound along the path."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_upper_bound_azimuth_metadata)

    _set_upper_bound_azimuth_metadata = { "offset" : _set_upper_bound_azimuth_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @upper_bound_azimuth.setter
    def upper_bound_azimuth(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._set_upper_bound_azimuth_metadata, value)

    _get_lower_bound_elevation_metadata = { "offset" : _get_lower_bound_elevation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lower_bound_elevation(self) -> float:
        """Thrust direction elevation lower bound along the path."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_lower_bound_elevation_metadata)

    _set_lower_bound_elevation_metadata = { "offset" : _set_lower_bound_elevation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lower_bound_elevation.setter
    def lower_bound_elevation(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._set_lower_bound_elevation_metadata, value)

    _get_upper_bound_elevation_metadata = { "offset" : _get_upper_bound_elevation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def upper_bound_elevation(self) -> float:
        """Thrust direction elevation upper bound along the path."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_upper_bound_elevation_metadata)

    _set_upper_bound_elevation_metadata = { "offset" : _set_upper_bound_elevation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @upper_bound_elevation.setter
    def upper_bound_elevation(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._set_upper_bound_elevation_metadata, value)

    _get_provide_runtime_type_info_metadata = { "offset" : _get_provide_runtime_type_info_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def provide_runtime_type_info(self) -> "RuntimeTypeInfo":
        """Return the RuntimeTypeInfo interface to access properties at runtime."""
        return self._intf.get_property(ManeuverOptimalFinitePathBoundaryConditions._metadata, ManeuverOptimalFinitePathBoundaryConditions._get_provide_runtime_type_info_metadata)

    _property_names[compute_from_initial_guess] = "compute_from_initial_guess"
    _property_names[a] = "a"
    _property_names[h] = "h"
    _property_names[k] = "k"
    _property_names[p] = "p"
    _property_names[q] = "q"
    _property_names[l] = "l"
    _property_names[lower_bound_azimuth] = "lower_bound_azimuth"
    _property_names[upper_bound_azimuth] = "upper_bound_azimuth"
    _property_names[lower_bound_elevation] = "lower_bound_elevation"
    _property_names[upper_bound_elevation] = "upper_bound_elevation"
    _property_names[provide_runtime_type_info] = "provide_runtime_type_info"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFinitePathBoundaryConditions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFinitePathBoundaryConditions)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFinitePathBoundaryConditions, [ManeuverOptimalFinitePathBoundaryConditions, ])

agcls.AgClassCatalog.add_catalog_entry((4897975046961720324, 9957266801658589367), ManeuverOptimalFinitePathBoundaryConditions)
agcls.AgTypeNameMap["ManeuverOptimalFinitePathBoundaryConditions"] = ManeuverOptimalFinitePathBoundaryConditions

class ManeuverOptimalFiniteSteeringNodeElement(SupportsDeleteCallback):
    """The elements of the steering node."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_node_index_method_offset = 1
    _get_time_method_offset = 2
    _get_mass_method_offset = 3
    _get_azimuth_method_offset = 4
    _get_elevation_method_offset = 5
    _get_direction_cos_x_method_offset = 6
    _get_direction_cos_y_method_offset = 7
    _get_direction_cos_z_method_offset = 8
    _get_position_x_method_offset = 9
    _get_position_y_method_offset = 10
    _get_position_z_method_offset = 11
    _get_velocity_x_method_offset = 12
    _get_velocity_y_method_offset = 13
    _get_velocity_z_method_offset = 14
    _metadata = {
        "iid_data" : (5681974857341656774, 10284978685885765302),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteSteeringNodeElement)

    _get_node_index_metadata = { "offset" : _get_node_index_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def node_index(self) -> int:
        """Get the index of the node in the array of nodes."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_node_index_metadata)

    _get_time_metadata = { "offset" : _get_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time(self) -> float:
        """Get the time associated with the node."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_time_metadata)

    _get_mass_metadata = { "offset" : _get_mass_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mass(self) -> float:
        """Get the mass at the node."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_mass_metadata)

    _get_azimuth_metadata = { "offset" : _get_azimuth_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def azimuth(self) -> float:
        """Get the azimuth of the steering angle."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_azimuth_metadata)

    _get_elevation_metadata = { "offset" : _get_elevation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def elevation(self) -> float:
        """Get the elevation of the steering angle."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_elevation_metadata)

    _get_direction_cos_x_metadata = { "offset" : _get_direction_cos_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def direction_cos_x(self) -> float:
        """Get the first component of the steering unit vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_direction_cos_x_metadata)

    _get_direction_cos_y_metadata = { "offset" : _get_direction_cos_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def direction_cos_y(self) -> float:
        """Get the second component of the steering unit vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_direction_cos_y_metadata)

    _get_direction_cos_z_metadata = { "offset" : _get_direction_cos_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def direction_cos_z(self) -> float:
        """Get the third component of the steering unit vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_direction_cos_z_metadata)

    _get_position_x_metadata = { "offset" : _get_position_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def position_x(self) -> float:
        """Get the X component of the position vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_position_x_metadata)

    _get_position_y_metadata = { "offset" : _get_position_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def position_y(self) -> float:
        """Get the Y component of the position vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_position_y_metadata)

    _get_position_z_metadata = { "offset" : _get_position_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def position_z(self) -> float:
        """Get the Z component of the position vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_position_z_metadata)

    _get_velocity_x_metadata = { "offset" : _get_velocity_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_x(self) -> float:
        """Get the X component of the velocity vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_velocity_x_metadata)

    _get_velocity_y_metadata = { "offset" : _get_velocity_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_y(self) -> float:
        """Get the Y component of the velocity vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_velocity_y_metadata)

    _get_velocity_z_metadata = { "offset" : _get_velocity_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_z(self) -> float:
        """Get the Z component of the velocity vector."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeElement._metadata, ManeuverOptimalFiniteSteeringNodeElement._get_velocity_z_metadata)

    _property_names[node_index] = "node_index"
    _property_names[time] = "time"
    _property_names[mass] = "mass"
    _property_names[azimuth] = "azimuth"
    _property_names[elevation] = "elevation"
    _property_names[direction_cos_x] = "direction_cos_x"
    _property_names[direction_cos_y] = "direction_cos_y"
    _property_names[direction_cos_z] = "direction_cos_z"
    _property_names[position_x] = "position_x"
    _property_names[position_y] = "position_y"
    _property_names[position_z] = "position_z"
    _property_names[velocity_x] = "velocity_x"
    _property_names[velocity_y] = "velocity_y"
    _property_names[velocity_z] = "velocity_z"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteSteeringNodeElement."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteSteeringNodeElement)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteSteeringNodeElement, [ManeuverOptimalFiniteSteeringNodeElement, ])

agcls.AgClassCatalog.add_catalog_entry((5696406060930657926, 17218302901274105782), ManeuverOptimalFiniteSteeringNodeElement)
agcls.AgTypeNameMap["ManeuverOptimalFiniteSteeringNodeElement"] = ManeuverOptimalFiniteSteeringNodeElement

class ManeuverOptimalFiniteSteeringNodeCollection(SupportsDeleteCallback):
    """Steering/nodes collection."""

    _num_methods = 3
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _metadata = {
        "iid_data" : (5138882826234024662, 1556125155199223470),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteSteeringNodeCollection)
    def __iter__(self):
        """Create an iterator for the ManeuverOptimalFiniteSteeringNodeCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ManeuverOptimalFiniteSteeringNodeElement":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "ManeuverOptimalFiniteSteeringNodeElement":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(ManeuverOptimalFiniteSteeringNodeCollection._metadata, ManeuverOptimalFiniteSteeringNodeCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeCollection._metadata, ManeuverOptimalFiniteSteeringNodeCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(ManeuverOptimalFiniteSteeringNodeCollection._metadata, ManeuverOptimalFiniteSteeringNodeCollection._get_count_metadata)

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteSteeringNodeCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteSteeringNodeCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteSteeringNodeCollection, [ManeuverOptimalFiniteSteeringNodeCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5393217767348672036, 7434771889247315870), ManeuverOptimalFiniteSteeringNodeCollection)
agcls.AgTypeNameMap["ManeuverOptimalFiniteSteeringNodeCollection"] = ManeuverOptimalFiniteSteeringNodeCollection

class ManeuverOptimalFiniteBounds(SupportsDeleteCallback):
    """The bounds for boundary interfaces."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_lower_bound_method_offset = 1
    _set_lower_bound_method_offset = 2
    _get_upper_bound_method_offset = 3
    _set_upper_bound_method_offset = 4
    _metadata = {
        "iid_data" : (4890434832875217083, 2136658822181412241),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ManeuverOptimalFiniteBounds)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lower_bound(self) -> float:
        """Lower bound for a boundary element."""
        return self._intf.get_property(ManeuverOptimalFiniteBounds._metadata, ManeuverOptimalFiniteBounds._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lower_bound.setter
    def lower_bound(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteBounds._metadata, ManeuverOptimalFiniteBounds._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def upper_bound(self) -> float:
        """Upper bound for a boundary element."""
        return self._intf.get_property(ManeuverOptimalFiniteBounds._metadata, ManeuverOptimalFiniteBounds._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @upper_bound.setter
    def upper_bound(self, value:float) -> None:
        return self._intf.set_property(ManeuverOptimalFiniteBounds._metadata, ManeuverOptimalFiniteBounds._set_upper_bound_metadata, value)

    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"

    def __init__(self, source_object=None):
        """Construct an object of type ManeuverOptimalFiniteBounds."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ManeuverOptimalFiniteBounds)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ManeuverOptimalFiniteBounds, [ManeuverOptimalFiniteBounds, ])

agcls.AgClassCatalog.add_catalog_entry((5146246105135506503, 247496315851455622), ManeuverOptimalFiniteBounds)
agcls.AgTypeNameMap["ManeuverOptimalFiniteBounds"] = ManeuverOptimalFiniteBounds

class ProfileLambertProfile(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Lambert profile."""

    _num_methods = 56
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_target_coordinate_type_method_offset = 3
    _set_target_coord_type_method_offset = 4
    _get_enable_second_maneuver_method_offset = 5
    _set_enable_second_maneuver_method_offset = 6
    _get_target_position_x_method_offset = 7
    _set_target_position_x_method_offset = 8
    _get_target_position_y_method_offset = 9
    _set_target_position_y_method_offset = 10
    _get_target_position_z_method_offset = 11
    _set_target_position_z_method_offset = 12
    _get_target_velocity_x_method_offset = 13
    _set_target_velocity_x_method_offset = 14
    _get_target_velocity_y_method_offset = 15
    _set_target_velocity_y_method_offset = 16
    _get_target_velocity_z_method_offset = 17
    _set_target_velocity_z_method_offset = 18
    _get_target_semimajor_axis_method_offset = 19
    _set_target_semimajor_axis_method_offset = 20
    _get_target_eccentricity_method_offset = 21
    _set_target_eccentricity_method_offset = 22
    _get_target_inclination_method_offset = 23
    _set_target_inclination_method_offset = 24
    _get_target_right_ascension_of_ascending_node_method_offset = 25
    _set_target_right_ascension_of_ascending_node_method_offset = 26
    _get_target_argument_of_periapsis_method_offset = 27
    _set_target_argument_of_periapsis_method_offset = 28
    _get_target_true_anomaly_method_offset = 29
    _set_target_true_anomaly_method_offset = 30
    _get_solution_option_method_offset = 31
    _set_solution_option_method_offset = 32
    _get_time_of_flight_method_offset = 33
    _set_time_of_flight_method_offset = 34
    _get_revolutions_method_offset = 35
    _set_revolutions_method_offset = 36
    _get_orbital_energy_method_offset = 37
    _set_orbital_energy_method_offset = 38
    _get_direction_of_motion_method_offset = 39
    _set_direction_of_motion_method_offset = 40
    _get_central_body_collision_altitude_padding_method_offset = 41
    _set_central_body_collision_altitude_padding_method_offset = 42
    _get_enable_write_to_first_maneuver_method_offset = 43
    _set_enable_write_to_first_maneuver_method_offset = 44
    _get_first_maneuver_segment_method_offset = 45
    _set_first_maneuver_segment_method_offset = 46
    _get_enable_write_duration_to_propagate_method_offset = 47
    _set_enable_write_duration_to_propagate_method_offset = 48
    _get_disable_non_lambert_propagate_stop_conditions_method_offset = 49
    _set_disable_non_lambert_propagate_stop_conditions_method_offset = 50
    _get_propagate_segment_method_offset = 51
    _set_propagate_segment_method_offset = 52
    _get_enable_write_to_second_maneuver_method_offset = 53
    _set_enable_write_to_second_maneuver_method_offset = 54
    _get_second_maneuver_segment_method_offset = 55
    _set_second_maneuver_segment_method_offset = 56
    _metadata = {
        "iid_data" : (5131435118186162975, 3470838594007664273),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileLambertProfile)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_coord_system_name_metadata, value)

    _get_target_coordinate_type_metadata = { "offset" : _get_target_coordinate_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LambertTargetCoordinateType),) }
    @property
    def target_coordinate_type(self) -> "LambertTargetCoordinateType":
        """Get the target coordinate type."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_coordinate_type_metadata)

    _set_target_coord_type_metadata = { "offset" : _set_target_coord_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LambertTargetCoordinateType),) }
    def set_target_coord_type(self, element_type:"LambertTargetCoordinateType") -> None:
        """Select a target coordinate type."""
        return self._intf.invoke(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_coord_type_metadata, element_type)

    _get_enable_second_maneuver_metadata = { "offset" : _get_enable_second_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_second_maneuver(self) -> bool:
        """Enable to calculate second maneuver at destination."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_enable_second_maneuver_metadata)

    _set_enable_second_maneuver_metadata = { "offset" : _set_enable_second_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_second_maneuver.setter
    def enable_second_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_enable_second_maneuver_metadata, value)

    _get_target_position_x_metadata = { "offset" : _get_target_position_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_x(self) -> float:
        """Get or set the X component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_position_x_metadata)

    _set_target_position_x_metadata = { "offset" : _set_target_position_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_x.setter
    def target_position_x(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_position_x_metadata, value)

    _get_target_position_y_metadata = { "offset" : _get_target_position_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_y(self) -> float:
        """Get or set the Y component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_position_y_metadata)

    _set_target_position_y_metadata = { "offset" : _set_target_position_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_y.setter
    def target_position_y(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_position_y_metadata, value)

    _get_target_position_z_metadata = { "offset" : _get_target_position_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_z(self) -> float:
        """Get or set the Z component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_position_z_metadata)

    _set_target_position_z_metadata = { "offset" : _set_target_position_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_z.setter
    def target_position_z(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_position_z_metadata, value)

    _get_target_velocity_x_metadata = { "offset" : _get_target_velocity_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_x(self) -> float:
        """Get or set the X component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_velocity_x_metadata)

    _set_target_velocity_x_metadata = { "offset" : _set_target_velocity_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_x.setter
    def target_velocity_x(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_velocity_x_metadata, value)

    _get_target_velocity_y_metadata = { "offset" : _get_target_velocity_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_y(self) -> float:
        """Get or set the Y component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_velocity_y_metadata)

    _set_target_velocity_y_metadata = { "offset" : _set_target_velocity_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_y.setter
    def target_velocity_y(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_velocity_y_metadata, value)

    _get_target_velocity_z_metadata = { "offset" : _get_target_velocity_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_z(self) -> float:
        """Get or set the Z component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_velocity_z_metadata)

    _set_target_velocity_z_metadata = { "offset" : _set_target_velocity_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_z.setter
    def target_velocity_z(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_velocity_z_metadata, value)

    _get_target_semimajor_axis_metadata = { "offset" : _get_target_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_semimajor_axis(self) -> float:
        """Get or set the target semimajor axis for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_semimajor_axis_metadata)

    _set_target_semimajor_axis_metadata = { "offset" : _set_target_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_semimajor_axis.setter
    def target_semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_semimajor_axis_metadata, value)

    _get_target_eccentricity_metadata = { "offset" : _get_target_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_eccentricity(self) -> float:
        """Get or set the target eccentricity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_eccentricity_metadata)

    _set_target_eccentricity_metadata = { "offset" : _set_target_eccentricity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_eccentricity.setter
    def target_eccentricity(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_eccentricity_metadata, value)

    _get_target_inclination_metadata = { "offset" : _get_target_inclination_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_inclination(self) -> float:
        """Get or set the target inclination for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_inclination_metadata)

    _set_target_inclination_metadata = { "offset" : _set_target_inclination_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_inclination.setter
    def target_inclination(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_inclination_metadata, value)

    _get_target_right_ascension_of_ascending_node_metadata = { "offset" : _get_target_right_ascension_of_ascending_node_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_right_ascension_of_ascending_node(self) -> float:
        """Get or set the target right ascension of the ascending node for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_right_ascension_of_ascending_node_metadata)

    _set_target_right_ascension_of_ascending_node_metadata = { "offset" : _set_target_right_ascension_of_ascending_node_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_right_ascension_of_ascending_node.setter
    def target_right_ascension_of_ascending_node(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_right_ascension_of_ascending_node_metadata, value)

    _get_target_argument_of_periapsis_metadata = { "offset" : _get_target_argument_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_argument_of_periapsis(self) -> float:
        """Get or set the target argument of periapsis for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_argument_of_periapsis_metadata)

    _set_target_argument_of_periapsis_metadata = { "offset" : _set_target_argument_of_periapsis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_argument_of_periapsis.setter
    def target_argument_of_periapsis(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_argument_of_periapsis_metadata, value)

    _get_target_true_anomaly_metadata = { "offset" : _get_target_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_true_anomaly(self) -> float:
        """Get or set the target true anomaly for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_target_true_anomaly_metadata)

    _set_target_true_anomaly_metadata = { "offset" : _set_target_true_anomaly_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_true_anomaly.setter
    def target_true_anomaly(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_target_true_anomaly_metadata, value)

    _get_solution_option_metadata = { "offset" : _get_solution_option_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LambertSolutionOptionType),) }
    @property
    def solution_option(self) -> "LambertSolutionOptionType":
        """Lambert solution calculation type."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_solution_option_metadata)

    _set_solution_option_metadata = { "offset" : _set_solution_option_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LambertSolutionOptionType),) }
    @solution_option.setter
    def solution_option(self, value:"LambertSolutionOptionType") -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_solution_option_metadata, value)

    _get_time_of_flight_metadata = { "offset" : _get_time_of_flight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_of_flight(self) -> float:
        """Get or set the time of flight between departure and arrival for the Lambert solution."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_time_of_flight_metadata)

    _set_time_of_flight_metadata = { "offset" : _set_time_of_flight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_of_flight.setter
    def time_of_flight(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_time_of_flight_metadata, value)

    _get_revolutions_metadata = { "offset" : _get_revolutions_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def revolutions(self) -> int:
        """Get or set the number of revolutions. Dimensionless."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_revolutions_metadata)

    _set_revolutions_metadata = { "offset" : _set_revolutions_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @revolutions.setter
    def revolutions(self, value:int) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_revolutions_metadata, value)

    _get_orbital_energy_metadata = { "offset" : _get_orbital_energy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LambertOrbitalEnergyType),) }
    @property
    def orbital_energy(self) -> "LambertOrbitalEnergyType":
        """Get or set the orbital energy for the Lambert solution."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_orbital_energy_metadata)

    _set_orbital_energy_metadata = { "offset" : _set_orbital_energy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LambertOrbitalEnergyType),) }
    @orbital_energy.setter
    def orbital_energy(self, value:"LambertOrbitalEnergyType") -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_orbital_energy_metadata, value)

    _get_direction_of_motion_metadata = { "offset" : _get_direction_of_motion_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LambertDirectionOfMotionType),) }
    @property
    def direction_of_motion(self) -> "LambertDirectionOfMotionType":
        """Get or set the direction of motion (long or short) for the Lambert solution."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_direction_of_motion_metadata)

    _set_direction_of_motion_metadata = { "offset" : _set_direction_of_motion_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LambertDirectionOfMotionType),) }
    @direction_of_motion.setter
    def direction_of_motion(self, value:"LambertDirectionOfMotionType") -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_direction_of_motion_metadata, value)

    _get_central_body_collision_altitude_padding_metadata = { "offset" : _get_central_body_collision_altitude_padding_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def central_body_collision_altitude_padding(self) -> float:
        """Get or set the minimum altitude below which the Lambert algorithm will consider the spacecraft to have hit the central body."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_central_body_collision_altitude_padding_metadata)

    _set_central_body_collision_altitude_padding_metadata = { "offset" : _set_central_body_collision_altitude_padding_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @central_body_collision_altitude_padding.setter
    def central_body_collision_altitude_padding(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_central_body_collision_altitude_padding_metadata, value)

    _get_enable_write_to_first_maneuver_metadata = { "offset" : _get_enable_write_to_first_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_to_first_maneuver(self) -> bool:
        """Set this to true to write the Delta-V solution from Lambert at the start of the transfer to the linked maneuver."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_enable_write_to_first_maneuver_metadata)

    _set_enable_write_to_first_maneuver_metadata = { "offset" : _set_enable_write_to_first_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_to_first_maneuver.setter
    def enable_write_to_first_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_enable_write_to_first_maneuver_metadata, value)

    _get_first_maneuver_segment_metadata = { "offset" : _get_first_maneuver_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def first_maneuver_segment(self) -> str:
        """Get or set the first maneuver segment to manipulate that occurs at the start of the transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_first_maneuver_segment_metadata)

    _set_first_maneuver_segment_metadata = { "offset" : _set_first_maneuver_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @first_maneuver_segment.setter
    def first_maneuver_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_first_maneuver_segment_metadata, value)

    _get_enable_write_duration_to_propagate_metadata = { "offset" : _get_enable_write_duration_to_propagate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_duration_to_propagate(self) -> bool:
        """Set this to true to write the Lambert duration of transfer to the 'LambertDuration' stopping condition in the linked propagate segment."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_enable_write_duration_to_propagate_metadata)

    _set_enable_write_duration_to_propagate_metadata = { "offset" : _set_enable_write_duration_to_propagate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_duration_to_propagate.setter
    def enable_write_duration_to_propagate(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_enable_write_duration_to_propagate_metadata, value)

    _get_disable_non_lambert_propagate_stop_conditions_metadata = { "offset" : _get_disable_non_lambert_propagate_stop_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def disable_non_lambert_propagate_stop_conditions(self) -> bool:
        """Set this to true to disable all non-LambertDuration stopping conditions in the propagate segment."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_disable_non_lambert_propagate_stop_conditions_metadata)

    _set_disable_non_lambert_propagate_stop_conditions_metadata = { "offset" : _set_disable_non_lambert_propagate_stop_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @disable_non_lambert_propagate_stop_conditions.setter
    def disable_non_lambert_propagate_stop_conditions(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_disable_non_lambert_propagate_stop_conditions_metadata, value)

    _get_propagate_segment_metadata = { "offset" : _get_propagate_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propagate_segment(self) -> str:
        """Get or set the propagate segment to manipulate that contains the transfer duration."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_propagate_segment_metadata)

    _set_propagate_segment_metadata = { "offset" : _set_propagate_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @propagate_segment.setter
    def propagate_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_propagate_segment_metadata, value)

    _get_enable_write_to_second_maneuver_metadata = { "offset" : _get_enable_write_to_second_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_to_second_maneuver(self) -> bool:
        """Set this to true to write the Delta-V solution from Lambert at the end of the transfer to the linked maneuver."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_enable_write_to_second_maneuver_metadata)

    _set_enable_write_to_second_maneuver_metadata = { "offset" : _set_enable_write_to_second_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_to_second_maneuver.setter
    def enable_write_to_second_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_enable_write_to_second_maneuver_metadata, value)

    _get_second_maneuver_segment_metadata = { "offset" : _get_second_maneuver_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def second_maneuver_segment(self) -> str:
        """Get or set the second maneuver segment to manipulate that occurs at the end of the transfer."""
        return self._intf.get_property(ProfileLambertProfile._metadata, ProfileLambertProfile._get_second_maneuver_segment_metadata)

    _set_second_maneuver_segment_metadata = { "offset" : _set_second_maneuver_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @second_maneuver_segment.setter
    def second_maneuver_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertProfile._metadata, ProfileLambertProfile._set_second_maneuver_segment_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[target_coordinate_type] = "target_coordinate_type"
    _property_names[enable_second_maneuver] = "enable_second_maneuver"
    _property_names[target_position_x] = "target_position_x"
    _property_names[target_position_y] = "target_position_y"
    _property_names[target_position_z] = "target_position_z"
    _property_names[target_velocity_x] = "target_velocity_x"
    _property_names[target_velocity_y] = "target_velocity_y"
    _property_names[target_velocity_z] = "target_velocity_z"
    _property_names[target_semimajor_axis] = "target_semimajor_axis"
    _property_names[target_eccentricity] = "target_eccentricity"
    _property_names[target_inclination] = "target_inclination"
    _property_names[target_right_ascension_of_ascending_node] = "target_right_ascension_of_ascending_node"
    _property_names[target_argument_of_periapsis] = "target_argument_of_periapsis"
    _property_names[target_true_anomaly] = "target_true_anomaly"
    _property_names[solution_option] = "solution_option"
    _property_names[time_of_flight] = "time_of_flight"
    _property_names[revolutions] = "revolutions"
    _property_names[orbital_energy] = "orbital_energy"
    _property_names[direction_of_motion] = "direction_of_motion"
    _property_names[central_body_collision_altitude_padding] = "central_body_collision_altitude_padding"
    _property_names[enable_write_to_first_maneuver] = "enable_write_to_first_maneuver"
    _property_names[first_maneuver_segment] = "first_maneuver_segment"
    _property_names[enable_write_duration_to_propagate] = "enable_write_duration_to_propagate"
    _property_names[disable_non_lambert_propagate_stop_conditions] = "disable_non_lambert_propagate_stop_conditions"
    _property_names[propagate_segment] = "propagate_segment"
    _property_names[enable_write_to_second_maneuver] = "enable_write_to_second_maneuver"
    _property_names[second_maneuver_segment] = "second_maneuver_segment"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileLambertProfile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileLambertProfile)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileLambertProfile, [ProfileLambertProfile, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5105045193344882222, 12893260449528183951), ProfileLambertProfile)
agcls.AgTypeNameMap["ProfileLambertProfile"] = ProfileLambertProfile

class ProfileLambertSearchProfile(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Lambert Search Profile."""

    _num_methods = 64
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_coord_system_name_method_offset = 1
    _set_coord_system_name_method_offset = 2
    _get_target_coordinate_type_method_offset = 3
    _set_target_coord_type_method_offset = 4
    _get_enable_second_maneuver_method_offset = 5
    _set_enable_second_maneuver_method_offset = 6
    _get_enable_target_match_phase_method_offset = 7
    _set_enable_target_match_phase_method_offset = 8
    _get_target_position_x_method_offset = 9
    _set_target_position_x_method_offset = 10
    _get_target_position_y_method_offset = 11
    _set_target_position_y_method_offset = 12
    _get_target_position_z_method_offset = 13
    _set_target_position_z_method_offset = 14
    _get_target_velocity_x_method_offset = 15
    _set_target_velocity_x_method_offset = 16
    _get_target_velocity_y_method_offset = 17
    _set_target_velocity_y_method_offset = 18
    _get_target_velocity_z_method_offset = 19
    _set_target_velocity_z_method_offset = 20
    _get_target_semimajor_axis_method_offset = 21
    _set_target_semimajor_axis_method_offset = 22
    _get_target_eccentricity_method_offset = 23
    _set_target_eccentricity_method_offset = 24
    _get_target_inclination_method_offset = 25
    _set_target_inclination_method_offset = 26
    _get_target_right_ascension_of_ascending_node_method_offset = 27
    _set_target_right_ascension_of_ascending_node_method_offset = 28
    _get_target_argument_of_periapsis_method_offset = 29
    _set_target_argument_of_periapsis_method_offset = 30
    _get_target_true_anomaly_method_offset = 31
    _set_target_true_anomaly_method_offset = 32
    _get_enable_write_departure_delay_to_first_propagate_method_offset = 33
    _set_enable_write_departure_delay_to_first_propagate_method_offset = 34
    _get_disable_first_propagate_non_lambert_stop_conditions_method_offset = 35
    _set_disable_first_propagate_non_lambert_stop_conditions_method_offset = 36
    _get_first_propagate_segment_method_offset = 37
    _set_first_propagate_segment_method_offset = 38
    _get_enable_write_to_first_maneuver_method_offset = 39
    _set_enable_write_to_first_maneuver_method_offset = 40
    _get_first_maneuver_segment_method_offset = 41
    _set_first_maneuver_segment_method_offset = 42
    _get_latest_departure_time_method_offset = 43
    _set_latest_departure_time_method_offset = 44
    _get_earliest_arrival_time_method_offset = 45
    _set_earliest_arrival_time_method_offset = 46
    _get_latest_arrival_time_method_offset = 47
    _set_latest_arrival_time_method_offset = 48
    _get_grid_search_time_step_method_offset = 49
    _set_grid_search_time_step_method_offset = 50
    _get_max_revolutions_method_offset = 51
    _set_max_revolutions_method_offset = 52
    _get_central_body_collision_altitude_padding_method_offset = 53
    _set_central_body_collision_altitude_padding_method_offset = 54
    _get_enable_write_duration_to_second_propagate_method_offset = 55
    _set_enable_write_duration_to_second_propagate_method_offset = 56
    _get_disable_second_propagate_non_lambert_stop_conditions_method_offset = 57
    _set_disable_second_propagate_non_lambert_stop_conditions_method_offset = 58
    _get_second_propagate_segment_method_offset = 59
    _set_second_propagate_segment_method_offset = 60
    _get_enable_write_to_second_maneuver_method_offset = 61
    _set_enable_write_to_second_maneuver_method_offset = 62
    _get_second_maneuver_segment_method_offset = 63
    _set_second_maneuver_segment_method_offset = 64
    _metadata = {
        "iid_data" : (4665356793630001439, 491401694762539420),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileLambertSearchProfile)

    _get_coord_system_name_metadata = { "offset" : _get_coord_system_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def coord_system_name(self) -> str:
        """Get or set the coordinate system."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_coord_system_name_metadata)

    _set_coord_system_name_metadata = { "offset" : _set_coord_system_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @coord_system_name.setter
    def coord_system_name(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_coord_system_name_metadata, value)

    _get_target_coordinate_type_metadata = { "offset" : _get_target_coordinate_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LambertTargetCoordinateType),) }
    @property
    def target_coordinate_type(self) -> "LambertTargetCoordinateType":
        """Get the target coordinate type."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_coordinate_type_metadata)

    _set_target_coord_type_metadata = { "offset" : _set_target_coord_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LambertTargetCoordinateType),) }
    def set_target_coord_type(self, element_type:"LambertTargetCoordinateType") -> None:
        """Select a target coordinate type."""
        return self._intf.invoke(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_coord_type_metadata, element_type)

    _get_enable_second_maneuver_metadata = { "offset" : _get_enable_second_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_second_maneuver(self) -> bool:
        """Enable to calculate second maneuver at destination."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_second_maneuver_metadata)

    _set_enable_second_maneuver_metadata = { "offset" : _set_enable_second_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_second_maneuver.setter
    def enable_second_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_second_maneuver_metadata, value)

    _get_enable_target_match_phase_metadata = { "offset" : _get_enable_target_match_phase_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_target_match_phase(self) -> bool:
        """Set this to true if the satellite should match the phase of the orbit at the target."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_target_match_phase_metadata)

    _set_enable_target_match_phase_metadata = { "offset" : _set_enable_target_match_phase_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_target_match_phase.setter
    def enable_target_match_phase(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_target_match_phase_metadata, value)

    _get_target_position_x_metadata = { "offset" : _get_target_position_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_x(self) -> float:
        """Get or set the X component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_position_x_metadata)

    _set_target_position_x_metadata = { "offset" : _set_target_position_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_x.setter
    def target_position_x(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_position_x_metadata, value)

    _get_target_position_y_metadata = { "offset" : _get_target_position_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_y(self) -> float:
        """Get or set the Y component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_position_y_metadata)

    _set_target_position_y_metadata = { "offset" : _set_target_position_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_y.setter
    def target_position_y(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_position_y_metadata, value)

    _get_target_position_z_metadata = { "offset" : _get_target_position_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_position_z(self) -> float:
        """Get or set the Z component of the target position for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_position_z_metadata)

    _set_target_position_z_metadata = { "offset" : _set_target_position_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_position_z.setter
    def target_position_z(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_position_z_metadata, value)

    _get_target_velocity_x_metadata = { "offset" : _get_target_velocity_x_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_x(self) -> float:
        """Get or set the X component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_velocity_x_metadata)

    _set_target_velocity_x_metadata = { "offset" : _set_target_velocity_x_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_x.setter
    def target_velocity_x(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_velocity_x_metadata, value)

    _get_target_velocity_y_metadata = { "offset" : _get_target_velocity_y_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_y(self) -> float:
        """Get or set the Y component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_velocity_y_metadata)

    _set_target_velocity_y_metadata = { "offset" : _set_target_velocity_y_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_y.setter
    def target_velocity_y(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_velocity_y_metadata, value)

    _get_target_velocity_z_metadata = { "offset" : _get_target_velocity_z_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_velocity_z(self) -> float:
        """Get or set the Z component of the target velocity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_velocity_z_metadata)

    _set_target_velocity_z_metadata = { "offset" : _set_target_velocity_z_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_velocity_z.setter
    def target_velocity_z(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_velocity_z_metadata, value)

    _get_target_semimajor_axis_metadata = { "offset" : _get_target_semimajor_axis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_semimajor_axis(self) -> float:
        """Get or set the target semimajor axis for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_semimajor_axis_metadata)

    _set_target_semimajor_axis_metadata = { "offset" : _set_target_semimajor_axis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_semimajor_axis.setter
    def target_semimajor_axis(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_semimajor_axis_metadata, value)

    _get_target_eccentricity_metadata = { "offset" : _get_target_eccentricity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_eccentricity(self) -> float:
        """Get or set the target eccentricity for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_eccentricity_metadata)

    _set_target_eccentricity_metadata = { "offset" : _set_target_eccentricity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_eccentricity.setter
    def target_eccentricity(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_eccentricity_metadata, value)

    _get_target_inclination_metadata = { "offset" : _get_target_inclination_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_inclination(self) -> float:
        """Get or set the target inclination for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_inclination_metadata)

    _set_target_inclination_metadata = { "offset" : _set_target_inclination_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_inclination.setter
    def target_inclination(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_inclination_metadata, value)

    _get_target_right_ascension_of_ascending_node_metadata = { "offset" : _get_target_right_ascension_of_ascending_node_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_right_ascension_of_ascending_node(self) -> float:
        """Get or set the target right ascension of the ascending node for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_right_ascension_of_ascending_node_metadata)

    _set_target_right_ascension_of_ascending_node_metadata = { "offset" : _set_target_right_ascension_of_ascending_node_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_right_ascension_of_ascending_node.setter
    def target_right_ascension_of_ascending_node(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_right_ascension_of_ascending_node_metadata, value)

    _get_target_argument_of_periapsis_metadata = { "offset" : _get_target_argument_of_periapsis_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_argument_of_periapsis(self) -> float:
        """Get or set the target argument of periapsis for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_argument_of_periapsis_metadata)

    _set_target_argument_of_periapsis_metadata = { "offset" : _set_target_argument_of_periapsis_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_argument_of_periapsis.setter
    def target_argument_of_periapsis(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_argument_of_periapsis_metadata, value)

    _get_target_true_anomaly_metadata = { "offset" : _get_target_true_anomaly_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_true_anomaly(self) -> float:
        """Get or set the target true anomaly for the end of the Lambert transfer."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_target_true_anomaly_metadata)

    _set_target_true_anomaly_metadata = { "offset" : _set_target_true_anomaly_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_true_anomaly.setter
    def target_true_anomaly(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_target_true_anomaly_metadata, value)

    _get_enable_write_departure_delay_to_first_propagate_metadata = { "offset" : _get_enable_write_departure_delay_to_first_propagate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_departure_delay_to_first_propagate(self) -> bool:
        """Set this to true to write the departure delay duration before the Lambert transfer to the 'LambertDuration' stopping condition in the first linked propagate segment."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_write_departure_delay_to_first_propagate_metadata)

    _set_enable_write_departure_delay_to_first_propagate_metadata = { "offset" : _set_enable_write_departure_delay_to_first_propagate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_departure_delay_to_first_propagate.setter
    def enable_write_departure_delay_to_first_propagate(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_write_departure_delay_to_first_propagate_metadata, value)

    _get_disable_first_propagate_non_lambert_stop_conditions_metadata = { "offset" : _get_disable_first_propagate_non_lambert_stop_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def disable_first_propagate_non_lambert_stop_conditions(self) -> bool:
        """Set this to true to disable all non-LambertDuration stopping conditions in the first propagate segment."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_disable_first_propagate_non_lambert_stop_conditions_metadata)

    _set_disable_first_propagate_non_lambert_stop_conditions_metadata = { "offset" : _set_disable_first_propagate_non_lambert_stop_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @disable_first_propagate_non_lambert_stop_conditions.setter
    def disable_first_propagate_non_lambert_stop_conditions(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_disable_first_propagate_non_lambert_stop_conditions_metadata, value)

    _get_first_propagate_segment_metadata = { "offset" : _get_first_propagate_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def first_propagate_segment(self) -> str:
        """Get or set the propagate segment to manipulate that contains the departure delay."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_first_propagate_segment_metadata)

    _set_first_propagate_segment_metadata = { "offset" : _set_first_propagate_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @first_propagate_segment.setter
    def first_propagate_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_first_propagate_segment_metadata, value)

    _get_enable_write_to_first_maneuver_metadata = { "offset" : _get_enable_write_to_first_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_to_first_maneuver(self) -> bool:
        """Set this to true to write the Delta-V solution from Lambert at the start of the transfer to the linked maneuver."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_write_to_first_maneuver_metadata)

    _set_enable_write_to_first_maneuver_metadata = { "offset" : _set_enable_write_to_first_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_to_first_maneuver.setter
    def enable_write_to_first_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_write_to_first_maneuver_metadata, value)

    _get_first_maneuver_segment_metadata = { "offset" : _get_first_maneuver_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def first_maneuver_segment(self) -> str:
        """Get or set the first maneuver segment to manipulate that occurs at the start of the transfer. It is visible when you select Write Initial Inertial Delta-V to Maneuver."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_first_maneuver_segment_metadata)

    _set_first_maneuver_segment_metadata = { "offset" : _set_first_maneuver_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @first_maneuver_segment.setter
    def first_maneuver_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_first_maneuver_segment_metadata, value)

    _get_latest_departure_time_metadata = { "offset" : _get_latest_departure_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def latest_departure_time(self) -> float:
        """Get or set the latest time from the start of the target sequence for the first Lambert maneuver to occur."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_latest_departure_time_metadata)

    _set_latest_departure_time_metadata = { "offset" : _set_latest_departure_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @latest_departure_time.setter
    def latest_departure_time(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_latest_departure_time_metadata, value)

    _get_earliest_arrival_time_metadata = { "offset" : _get_earliest_arrival_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def earliest_arrival_time(self) -> float:
        """Get or set the earliest time from the start of the target sequence that the satellite should arrive at its destination."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_earliest_arrival_time_metadata)

    _set_earliest_arrival_time_metadata = { "offset" : _set_earliest_arrival_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @earliest_arrival_time.setter
    def earliest_arrival_time(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_earliest_arrival_time_metadata, value)

    _get_latest_arrival_time_metadata = { "offset" : _get_latest_arrival_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def latest_arrival_time(self) -> float:
        """Get or set the latest time from the start of the target sequence that the satellite should arrive at its destination."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_latest_arrival_time_metadata)

    _set_latest_arrival_time_metadata = { "offset" : _set_latest_arrival_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @latest_arrival_time.setter
    def latest_arrival_time(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_latest_arrival_time_metadata, value)

    _get_grid_search_time_step_metadata = { "offset" : _get_grid_search_time_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def grid_search_time_step(self) -> float:
        """Get or set the time step between Lambert evaluations for searching over both the departure window and arrival window of time."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_grid_search_time_step_metadata)

    _set_grid_search_time_step_metadata = { "offset" : _set_grid_search_time_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @grid_search_time_step.setter
    def grid_search_time_step(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_grid_search_time_step_metadata, value)

    _get_max_revolutions_metadata = { "offset" : _get_max_revolutions_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_revolutions(self) -> int:
        """Get or set the maximum number of revolutions for the Lambert solution."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_max_revolutions_metadata)

    _set_max_revolutions_metadata = { "offset" : _set_max_revolutions_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_revolutions.setter
    def max_revolutions(self, value:int) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_max_revolutions_metadata, value)

    _get_central_body_collision_altitude_padding_metadata = { "offset" : _get_central_body_collision_altitude_padding_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def central_body_collision_altitude_padding(self) -> float:
        """Get or set the minimum altitude below which the Lambert algorithm will consider the spacecraft to have hit the central body."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_central_body_collision_altitude_padding_metadata)

    _set_central_body_collision_altitude_padding_metadata = { "offset" : _set_central_body_collision_altitude_padding_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @central_body_collision_altitude_padding.setter
    def central_body_collision_altitude_padding(self, value:float) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_central_body_collision_altitude_padding_metadata, value)

    _get_enable_write_duration_to_second_propagate_metadata = { "offset" : _get_enable_write_duration_to_second_propagate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_duration_to_second_propagate(self) -> bool:
        """Set this to true to write the Lambert duration of transfer to the 'LambertDuration' stopping condition in the second linked propagate segment."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_write_duration_to_second_propagate_metadata)

    _set_enable_write_duration_to_second_propagate_metadata = { "offset" : _set_enable_write_duration_to_second_propagate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_duration_to_second_propagate.setter
    def enable_write_duration_to_second_propagate(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_write_duration_to_second_propagate_metadata, value)

    _get_disable_second_propagate_non_lambert_stop_conditions_metadata = { "offset" : _get_disable_second_propagate_non_lambert_stop_conditions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def disable_second_propagate_non_lambert_stop_conditions(self) -> bool:
        """Set this to true to disable all non-LambertDuration stopping conditions in the second propagate segment. This is visible when you select Write Flight Duration to Second Propagate."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_disable_second_propagate_non_lambert_stop_conditions_metadata)

    _set_disable_second_propagate_non_lambert_stop_conditions_metadata = { "offset" : _set_disable_second_propagate_non_lambert_stop_conditions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @disable_second_propagate_non_lambert_stop_conditions.setter
    def disable_second_propagate_non_lambert_stop_conditions(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_disable_second_propagate_non_lambert_stop_conditions_metadata, value)

    _get_second_propagate_segment_metadata = { "offset" : _get_second_propagate_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def second_propagate_segment(self) -> str:
        """Get or set the propagate segment to manipulate that contains the transfer duration. It is visible when you select Write Flight Duration to Second Propagate."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_second_propagate_segment_metadata)

    _set_second_propagate_segment_metadata = { "offset" : _set_second_propagate_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @second_propagate_segment.setter
    def second_propagate_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_second_propagate_segment_metadata, value)

    _get_enable_write_to_second_maneuver_metadata = { "offset" : _get_enable_write_to_second_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_write_to_second_maneuver(self) -> bool:
        """Set this to true to write the Delta-V solution from Lambert at the end of the transfer to the linked maneuver. It is visible when you select Calculate Second Maneuver At Destination ."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_enable_write_to_second_maneuver_metadata)

    _set_enable_write_to_second_maneuver_metadata = { "offset" : _set_enable_write_to_second_maneuver_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_write_to_second_maneuver.setter
    def enable_write_to_second_maneuver(self, value:bool) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_enable_write_to_second_maneuver_metadata, value)

    _get_second_maneuver_segment_metadata = { "offset" : _get_second_maneuver_segment_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def second_maneuver_segment(self) -> str:
        """Get or set the second maneuver segment to manipulate that occurs at the end of the transfer. It is visible when you select Write Final Inertial Delta-V to Maneuver."""
        return self._intf.get_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._get_second_maneuver_segment_metadata)

    _set_second_maneuver_segment_metadata = { "offset" : _set_second_maneuver_segment_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @second_maneuver_segment.setter
    def second_maneuver_segment(self, value:str) -> None:
        return self._intf.set_property(ProfileLambertSearchProfile._metadata, ProfileLambertSearchProfile._set_second_maneuver_segment_metadata, value)

    _property_names[coord_system_name] = "coord_system_name"
    _property_names[target_coordinate_type] = "target_coordinate_type"
    _property_names[enable_second_maneuver] = "enable_second_maneuver"
    _property_names[enable_target_match_phase] = "enable_target_match_phase"
    _property_names[target_position_x] = "target_position_x"
    _property_names[target_position_y] = "target_position_y"
    _property_names[target_position_z] = "target_position_z"
    _property_names[target_velocity_x] = "target_velocity_x"
    _property_names[target_velocity_y] = "target_velocity_y"
    _property_names[target_velocity_z] = "target_velocity_z"
    _property_names[target_semimajor_axis] = "target_semimajor_axis"
    _property_names[target_eccentricity] = "target_eccentricity"
    _property_names[target_inclination] = "target_inclination"
    _property_names[target_right_ascension_of_ascending_node] = "target_right_ascension_of_ascending_node"
    _property_names[target_argument_of_periapsis] = "target_argument_of_periapsis"
    _property_names[target_true_anomaly] = "target_true_anomaly"
    _property_names[enable_write_departure_delay_to_first_propagate] = "enable_write_departure_delay_to_first_propagate"
    _property_names[disable_first_propagate_non_lambert_stop_conditions] = "disable_first_propagate_non_lambert_stop_conditions"
    _property_names[first_propagate_segment] = "first_propagate_segment"
    _property_names[enable_write_to_first_maneuver] = "enable_write_to_first_maneuver"
    _property_names[first_maneuver_segment] = "first_maneuver_segment"
    _property_names[latest_departure_time] = "latest_departure_time"
    _property_names[earliest_arrival_time] = "earliest_arrival_time"
    _property_names[latest_arrival_time] = "latest_arrival_time"
    _property_names[grid_search_time_step] = "grid_search_time_step"
    _property_names[max_revolutions] = "max_revolutions"
    _property_names[central_body_collision_altitude_padding] = "central_body_collision_altitude_padding"
    _property_names[enable_write_duration_to_second_propagate] = "enable_write_duration_to_second_propagate"
    _property_names[disable_second_propagate_non_lambert_stop_conditions] = "disable_second_propagate_non_lambert_stop_conditions"
    _property_names[second_propagate_segment] = "second_propagate_segment"
    _property_names[enable_write_to_second_maneuver] = "enable_write_to_second_maneuver"
    _property_names[second_maneuver_segment] = "second_maneuver_segment"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileLambertSearchProfile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileLambertSearchProfile)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileLambertSearchProfile, [ProfileLambertSearchProfile, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5474786237822332834, 5691720590487098242), ProfileLambertSearchProfile)
agcls.AgTypeNameMap["ProfileLambertSearchProfile"] = ProfileLambertSearchProfile

class ProfileGoldenSection(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Golden Section profile."""

    _num_methods = 9
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_targeter_graphs_method_offset = 1
    _get_scripting_tool_method_offset = 2
    _get_controls_method_offset = 3
    _get_results_method_offset = 4
    _get_max_iterations_method_offset = 5
    _set_max_iterations_method_offset = 6
    _get_log_file_method_offset = 7
    _get_enable_display_status_method_offset = 8
    _set_enable_display_status_method_offset = 9
    _metadata = {
        "iid_data" : (4933620988574091389, 14999261045366057143),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileGoldenSection)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_targeter_graphs_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_scripting_tool_metadata)

    _get_controls_metadata = { "offset" : _get_controls_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def controls(self) -> "GoldenSectionControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_controls_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "GoldenSectionResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_results_metadata)

    _get_max_iterations_metadata = { "offset" : _get_max_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_iterations(self) -> int:
        """Get or set the number of complete iterations of the profile to try before stopping. Dimensionless."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_max_iterations_metadata)

    _set_max_iterations_metadata = { "offset" : _set_max_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_iterations.setter
    def max_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileGoldenSection._metadata, ProfileGoldenSection._set_max_iterations_metadata, value)

    _get_log_file_metadata = { "offset" : _get_log_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def log_file(self) -> str:
        """Name of the log file for this profile."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_log_file_metadata)

    _get_enable_display_status_metadata = { "offset" : _get_enable_display_status_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_display_status(self) -> bool:
        """If true, a page will appear during the targeting run to report the status of the targeting effort in terms of proximity to the desired value for each dependent variable in the profile."""
        return self._intf.get_property(ProfileGoldenSection._metadata, ProfileGoldenSection._get_enable_display_status_metadata)

    _set_enable_display_status_metadata = { "offset" : _set_enable_display_status_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_display_status.setter
    def enable_display_status(self, value:bool) -> None:
        return self._intf.set_property(ProfileGoldenSection._metadata, ProfileGoldenSection._set_enable_display_status_metadata, value)

    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[controls] = "controls"
    _property_names[results] = "results"
    _property_names[max_iterations] = "max_iterations"
    _property_names[log_file] = "log_file"
    _property_names[enable_display_status] = "enable_display_status"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileGoldenSection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileGoldenSection)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileGoldenSection, [ProfileGoldenSection, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5513205475854680150, 3336794135692898437), ProfileGoldenSection)
agcls.AgTypeNameMap["ProfileGoldenSection"] = ProfileGoldenSection

class GoldenSectionControlCollection(SupportsDeleteCallback):
    """Properties for the list of Golden Section control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (4979017413367074730, 8845884185412844198),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GoldenSectionControlCollection)
    def __iter__(self):
        """Create an iterator for the GoldenSectionControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "GoldenSectionControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "GoldenSectionControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(GoldenSectionControlCollection._metadata, GoldenSectionControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(GoldenSectionControlCollection._metadata, GoldenSectionControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(GoldenSectionControlCollection._metadata, GoldenSectionControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "GoldenSectionControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(GoldenSectionControlCollection._metadata, GoldenSectionControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type GoldenSectionControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GoldenSectionControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GoldenSectionControlCollection, [GoldenSectionControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5048787599091551597, 9878884015237706136), GoldenSectionControlCollection)
agcls.AgTypeNameMap["GoldenSectionControlCollection"] = GoldenSectionControlCollection

class GoldenSectionControl(SupportsDeleteCallback):
    """Properties for control parameters of a Golden Section profile."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_current_value_method_offset = 5
    _get_lower_bound_method_offset = 6
    _set_lower_bound_method_offset = 7
    _get_upper_bound_method_offset = 8
    _set_upper_bound_method_offset = 9
    _get_use_custom_display_unit_method_offset = 10
    _set_use_custom_display_unit_method_offset = 11
    _get_custom_display_unit_method_offset = 12
    _set_custom_display_unit_method_offset = 13
    _get_tolerance_method_offset = 14
    _set_tolerance_method_offset = 15
    _metadata = {
        "iid_data" : (5047558345947381297, 4599741228227139758),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GoldenSectionControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_parent_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_current_value_metadata)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_upper_bound_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_custom_display_unit_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tolerance(self) -> typing.Any:
        """How close the targeter should come to the desired. Dimension depends on context."""
        return self._intf.get_property(GoldenSectionControl._metadata, GoldenSectionControl._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tolerance.setter
    def tolerance(self, value:typing.Any) -> None:
        return self._intf.set_property(GoldenSectionControl._metadata, GoldenSectionControl._set_tolerance_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[current_value] = "current_value"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[tolerance] = "tolerance"

    def __init__(self, source_object=None):
        """Construct an object of type GoldenSectionControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GoldenSectionControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GoldenSectionControl, [GoldenSectionControl, ])

agcls.AgClassCatalog.add_catalog_entry((5740988849348914654, 3351787303745426560), GoldenSectionControl)
agcls.AgTypeNameMap["GoldenSectionControl"] = GoldenSectionControl

class GoldenSectionResultCollection(SupportsDeleteCallback):
    """Properties for the list of Golden Section result parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5409994296917849120, 6122413435407341964),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GoldenSectionResultCollection)
    def __iter__(self):
        """Create an iterator for the GoldenSectionResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "GoldenSectionResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "GoldenSectionResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(GoldenSectionResultCollection._metadata, GoldenSectionResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(GoldenSectionResultCollection._metadata, GoldenSectionResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(GoldenSectionResultCollection._metadata, GoldenSectionResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "GoldenSectionResult":
        """Return the result specified by the object/result path."""
        return self._intf.invoke(GoldenSectionResultCollection._metadata, GoldenSectionResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type GoldenSectionResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GoldenSectionResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GoldenSectionResultCollection, [GoldenSectionResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4688981584704829625, 17514973311597057458), GoldenSectionResultCollection)
agcls.AgTypeNameMap["GoldenSectionResultCollection"] = GoldenSectionResultCollection

class GoldenSectionResult(SupportsDeleteCallback):
    """Properties for result parameters of a Golden Section profile."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_current_value_method_offset = 5
    _get_desired_operation_method_offset = 6
    _set_desired_operation_method_offset = 7
    _get_use_custom_display_unit_method_offset = 8
    _set_use_custom_display_unit_method_offset = 9
    _get_custom_display_unit_method_offset = 10
    _set_custom_display_unit_method_offset = 11
    _metadata = {
        "iid_data" : (4846497611718727319, 542211254498659735),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GoldenSectionResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(GoldenSectionResult._metadata, GoldenSectionResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_parent_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_current_value_metadata)

    _get_desired_operation_metadata = { "offset" : _get_desired_operation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GoldenSectionDesiredOperation),) }
    @property
    def desired_operation(self) -> "GoldenSectionDesiredOperation":
        """Get or set the Desired Operation/Objective of golden section."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_desired_operation_metadata)

    _set_desired_operation_metadata = { "offset" : _set_desired_operation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GoldenSectionDesiredOperation),) }
    @desired_operation.setter
    def desired_operation(self, value:"GoldenSectionDesiredOperation") -> None:
        return self._intf.set_property(GoldenSectionResult._metadata, GoldenSectionResult._set_desired_operation_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(GoldenSectionResult._metadata, GoldenSectionResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(GoldenSectionResult._metadata, GoldenSectionResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(GoldenSectionResult._metadata, GoldenSectionResult._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[current_value] = "current_value"
    _property_names[desired_operation] = "desired_operation"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type GoldenSectionResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GoldenSectionResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GoldenSectionResult, [GoldenSectionResult, ])

agcls.AgClassCatalog.add_catalog_entry((5673153722049580977, 2874596235403525044), GoldenSectionResult)
agcls.AgTypeNameMap["GoldenSectionResult"] = GoldenSectionResult

class ProfileGridSearch(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties for a Grid Search profile."""

    _num_methods = 9
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_targeter_graphs_method_offset = 1
    _get_scripting_tool_method_offset = 2
    _get_controls_method_offset = 3
    _get_results_method_offset = 4
    _get_log_file_method_offset = 5
    _get_enable_display_status_method_offset = 6
    _set_enable_display_status_method_offset = 7
    _get_should_generate_graph_method_offset = 8
    _set_should_generate_graph_method_offset = 9
    _metadata = {
        "iid_data" : (5405732854479547480, 9799438297963148967),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileGridSearch)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_targeter_graphs_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_scripting_tool_metadata)

    _get_controls_metadata = { "offset" : _get_controls_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def controls(self) -> "GridSearchControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_controls_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "GridSearchResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_results_metadata)

    _get_log_file_metadata = { "offset" : _get_log_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def log_file(self) -> str:
        """Name of the log file for this profile."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_log_file_metadata)

    _get_enable_display_status_metadata = { "offset" : _get_enable_display_status_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_display_status(self) -> bool:
        """If true, a page will appear during the targeting run to report the status of the targeting effort in terms of proximity to the desired value for each dependent variable in the profile."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_enable_display_status_metadata)

    _set_enable_display_status_metadata = { "offset" : _set_enable_display_status_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_display_status.setter
    def enable_display_status(self, value:bool) -> None:
        return self._intf.set_property(ProfileGridSearch._metadata, ProfileGridSearch._set_enable_display_status_metadata, value)

    _get_should_generate_graph_metadata = { "offset" : _get_should_generate_graph_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def should_generate_graph(self) -> bool:
        """If true, a plot is automatically generate the selected result value versus the control value for the grid search when the profile runs."""
        return self._intf.get_property(ProfileGridSearch._metadata, ProfileGridSearch._get_should_generate_graph_metadata)

    _set_should_generate_graph_metadata = { "offset" : _set_should_generate_graph_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @should_generate_graph.setter
    def should_generate_graph(self, value:bool) -> None:
        return self._intf.set_property(ProfileGridSearch._metadata, ProfileGridSearch._set_should_generate_graph_metadata, value)

    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[controls] = "controls"
    _property_names[results] = "results"
    _property_names[log_file] = "log_file"
    _property_names[enable_display_status] = "enable_display_status"
    _property_names[should_generate_graph] = "should_generate_graph"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileGridSearch."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileGridSearch)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileGridSearch, [ProfileGridSearch, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((5524069762900486808, 16155020909550560909), ProfileGridSearch)
agcls.AgTypeNameMap["ProfileGridSearch"] = ProfileGridSearch

class GridSearchControlCollection(SupportsDeleteCallback):
    """Properties for the list of Grid Search control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (4691532401394199808, 17256766706916015489),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GridSearchControlCollection)
    def __iter__(self):
        """Create an iterator for the GridSearchControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "GridSearchControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "GridSearchControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(GridSearchControlCollection._metadata, GridSearchControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(GridSearchControlCollection._metadata, GridSearchControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(GridSearchControlCollection._metadata, GridSearchControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "GridSearchControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(GridSearchControlCollection._metadata, GridSearchControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type GridSearchControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GridSearchControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GridSearchControlCollection, [GridSearchControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5099714536736489649, 14219853598408991422), GridSearchControlCollection)
agcls.AgTypeNameMap["GridSearchControlCollection"] = GridSearchControlCollection

class GridSearchControl(SupportsDeleteCallback):
    """Properties for control parameters of a Grid Search profile."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_current_value_method_offset = 5
    _get_lower_bound_method_offset = 6
    _set_lower_bound_method_offset = 7
    _get_upper_bound_method_offset = 8
    _set_upper_bound_method_offset = 9
    _get_use_custom_display_unit_method_offset = 10
    _set_use_custom_display_unit_method_offset = 11
    _get_custom_display_unit_method_offset = 12
    _set_custom_display_unit_method_offset = 13
    _get_step_method_offset = 14
    _set_step_method_offset = 15
    _metadata = {
        "iid_data" : (5325393925969668946, 16093979779729701504),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GridSearchControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_parent_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_current_value_metadata)

    _get_lower_bound_metadata = { "offset" : _get_lower_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def lower_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_lower_bound_metadata)

    _set_lower_bound_metadata = { "offset" : _set_lower_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @lower_bound.setter
    def lower_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_lower_bound_metadata, value)

    _get_upper_bound_metadata = { "offset" : _get_upper_bound_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def upper_bound(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_upper_bound_metadata)

    _set_upper_bound_metadata = { "offset" : _set_upper_bound_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @upper_bound.setter
    def upper_bound(self, value:typing.Any) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_upper_bound_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_custom_display_unit_metadata, value)

    _get_step_metadata = { "offset" : _get_step_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def step(self) -> typing.Any:
        """Specify the step size to use when evaluating the grid search. Dimension depends on context."""
        return self._intf.get_property(GridSearchControl._metadata, GridSearchControl._get_step_metadata)

    _set_step_metadata = { "offset" : _set_step_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @step.setter
    def step(self, value:typing.Any) -> None:
        return self._intf.set_property(GridSearchControl._metadata, GridSearchControl._set_step_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[current_value] = "current_value"
    _property_names[lower_bound] = "lower_bound"
    _property_names[upper_bound] = "upper_bound"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"
    _property_names[step] = "step"

    def __init__(self, source_object=None):
        """Construct an object of type GridSearchControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GridSearchControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GridSearchControl, [GridSearchControl, ])

agcls.AgClassCatalog.add_catalog_entry((4746562151392512031, 8555222574508072328), GridSearchControl)
agcls.AgTypeNameMap["GridSearchControl"] = GridSearchControl

class GridSearchResultCollection(SupportsDeleteCallback):
    """Properties for the list of Grid Search result parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (4758661919879989672, 11442891986959097493),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GridSearchResultCollection)
    def __iter__(self):
        """Create an iterator for the GridSearchResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "GridSearchResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "GridSearchResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(GridSearchResultCollection._metadata, GridSearchResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(GridSearchResultCollection._metadata, GridSearchResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(GridSearchResultCollection._metadata, GridSearchResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "GridSearchResult":
        """Return the result specified by the object/result path."""
        return self._intf.invoke(GridSearchResultCollection._metadata, GridSearchResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type GridSearchResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GridSearchResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GridSearchResultCollection, [GridSearchResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5269787613116083574, 524079993261553293), GridSearchResultCollection)
agcls.AgTypeNameMap["GridSearchResultCollection"] = GridSearchResultCollection

class GridSearchResult(SupportsDeleteCallback):
    """Properties for result parameters of a Grid Search profile."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_current_value_method_offset = 5
    _get_desired_operation_method_offset = 6
    _set_desired_operation_method_offset = 7
    _get_use_custom_display_unit_method_offset = 8
    _set_use_custom_display_unit_method_offset = 9
    _get_custom_display_unit_method_offset = 10
    _set_custom_display_unit_method_offset = 11
    _metadata = {
        "iid_data" : (5085356470408734259, 12084031111375475366),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, GridSearchResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(GridSearchResult._metadata, GridSearchResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_parent_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_current_value_metadata)

    _get_desired_operation_metadata = { "offset" : _get_desired_operation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(GridSearchDesiredOperation),) }
    @property
    def desired_operation(self) -> "GridSearchDesiredOperation":
        """Get or set the Desired Operation/Objective of grid search."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_desired_operation_metadata)

    _set_desired_operation_metadata = { "offset" : _set_desired_operation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(GridSearchDesiredOperation),) }
    @desired_operation.setter
    def desired_operation(self, value:"GridSearchDesiredOperation") -> None:
        return self._intf.set_property(GridSearchResult._metadata, GridSearchResult._set_desired_operation_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(GridSearchResult._metadata, GridSearchResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(GridSearchResult._metadata, GridSearchResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(GridSearchResult._metadata, GridSearchResult._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[current_value] = "current_value"
    _property_names[desired_operation] = "desired_operation"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type GridSearchResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, GridSearchResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, GridSearchResult, [GridSearchResult, ])

agcls.AgClassCatalog.add_catalog_entry((4937096937333925880, 757142270461828760), GridSearchResult)
agcls.AgTypeNameMap["GridSearchResult"] = GridSearchResult

class CalculationObjectLinkEmbedControlCollection(SupportsDeleteCallback):
    """Collection of link/embed calculation objects."""

    _num_methods = 10
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _add_method_offset = 1
    _item_method_offset = 2
    _remove_method_offset = 3
    _get__new_enum_method_offset = 4
    _get_count_method_offset = 5
    _cut_method_offset = 6
    _paste_method_offset = 7
    _insert_copy_method_offset = 8
    _get_item_by_index_method_offset = 9
    _get_item_by_name_method_offset = 10
    _metadata = {
        "iid_data" : (5563123083513181514, 17290440528090745231),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CalculationObjectLinkEmbedControlCollection)
    def __iter__(self):
        """Create an iterator for the CalculationObjectLinkEmbedControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IComponentLinkEmbedControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.BSTR, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.EnumArg(ComponentLinkEmbedControlReferenceType), agmarshall.InterfaceOutArg,) }
    def add(self, name:str, ref_type:"ComponentLinkEmbedControlReferenceType") -> "IComponentLinkEmbedControl":
        """Add a link/embed calc object to the collection."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._add_metadata, name, ref_type, OutArg())

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.Variant, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.InterfaceOutArg,) }
    def item(self, index_or_name:typing.Any) -> "IComponentLinkEmbedControl":
        """Return a link/embed calc object."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._item_metadata, index_or_name, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def remove(self, index_or_name:typing.Any) -> None:
        """Remove a link/embed calc object from the collection."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._remove_metadata, index_or_name)

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._get_count_metadata)

    _cut_metadata = { "offset" : _cut_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def cut(self, index_or_name:typing.Any) -> None:
        """Copy a link/embed calc object to the clipboard and removes the calc object from the list."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._cut_metadata, index_or_name)

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def paste(self) -> "IComponentLinkEmbedControl":
        """Pastes a link/embed calc object from the clipboard into the list."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._paste_metadata, OutArg())

    _insert_copy_metadata = { "offset" : _insert_copy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IComponentLinkEmbedControl"), agmarshall.InterfaceOutArg,) }
    def insert_copy(self, calc_obj:"IComponentLinkEmbedControl") -> "IComponentLinkEmbedControl":
        """Copy a link/embed calc object and inserts the copy into the list."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._insert_copy_metadata, calc_obj, OutArg())

    _get_item_by_index_metadata = { "offset" : _get_item_by_index_method_offset,
            "arg_types" : (agcom.INT, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IntArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_index(self, index:int) -> "IComponentLinkEmbedControl":
        """Retrieve a link/embed calc object found by the index."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._get_item_by_index_metadata, index, OutArg())

    _get_item_by_name_metadata = { "offset" : _get_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_item_by_name(self, name:str) -> "IComponentLinkEmbedControl":
        """Retrieve a link/embed calc object found by the name."""
        return self._intf.invoke(CalculationObjectLinkEmbedControlCollection._metadata, CalculationObjectLinkEmbedControlCollection._get_item_by_name_metadata, name, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type CalculationObjectLinkEmbedControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CalculationObjectLinkEmbedControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CalculationObjectLinkEmbedControlCollection, [CalculationObjectLinkEmbedControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5719207221443687100, 18379399996235772605), CalculationObjectLinkEmbedControlCollection)
agcls.AgTypeNameMap["CalculationObjectLinkEmbedControlCollection"] = CalculationObjectLinkEmbedControlCollection

class ProfileBisection(IProfile, IRuntimeTypeInfoProvider, SupportsDeleteCallback):
    """Properties of Single Parameter Bisection profile."""

    _num_methods = 8
    _vtable_offset = IProfile._vtable_offset + IProfile._num_methods
    _get_control_parameters_method_offset = 1
    _get_results_method_offset = 2
    _get_targeter_graphs_method_offset = 3
    _get_scripting_tool_method_offset = 4
    _get_reset_controls_before_run_method_offset = 5
    _set_reset_controls_before_run_method_offset = 6
    _get_maximum_iterations_method_offset = 7
    _set_maximum_iterations_method_offset = 8
    _metadata = {
        "iid_data" : (4869548750746603413, 18221766685931608474),
        "vtable_reference" : IProfile._vtable_offset + IProfile._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProfileBisection)

    _get_control_parameters_metadata = { "offset" : _get_control_parameters_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def control_parameters(self) -> "BisectionControlCollection":
        """Get the list of control parameters defined for the profile."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_control_parameters_metadata)

    _get_results_metadata = { "offset" : _get_results_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def results(self) -> "BisectionResultCollection":
        """Get the list of results defined for the profile."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_results_metadata)

    _get_targeter_graphs_metadata = { "offset" : _get_targeter_graphs_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def targeter_graphs(self) -> "TargeterGraphCollection":
        """Graphs."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_targeter_graphs_metadata)

    _get_scripting_tool_metadata = { "offset" : _get_scripting_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scripting_tool(self) -> "ScriptingTool":
        """Return the Scripting tool for the sequence."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_scripting_tool_metadata)

    _get_reset_controls_before_run_metadata = { "offset" : _get_reset_controls_before_run_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reset_controls_before_run(self) -> bool:
        """Reset controls before each run."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_reset_controls_before_run_metadata)

    _set_reset_controls_before_run_metadata = { "offset" : _set_reset_controls_before_run_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reset_controls_before_run.setter
    def reset_controls_before_run(self, value:bool) -> None:
        return self._intf.set_property(ProfileBisection._metadata, ProfileBisection._set_reset_controls_before_run_metadata, value)

    _get_maximum_iterations_metadata = { "offset" : _get_maximum_iterations_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def maximum_iterations(self) -> int:
        """Get or set the maximum number of iterations allowed."""
        return self._intf.get_property(ProfileBisection._metadata, ProfileBisection._get_maximum_iterations_metadata)

    _set_maximum_iterations_metadata = { "offset" : _set_maximum_iterations_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @maximum_iterations.setter
    def maximum_iterations(self, value:int) -> None:
        return self._intf.set_property(ProfileBisection._metadata, ProfileBisection._set_maximum_iterations_metadata, value)

    _property_names[control_parameters] = "control_parameters"
    _property_names[results] = "results"
    _property_names[targeter_graphs] = "targeter_graphs"
    _property_names[scripting_tool] = "scripting_tool"
    _property_names[reset_controls_before_run] = "reset_controls_before_run"
    _property_names[maximum_iterations] = "maximum_iterations"

    def __init__(self, source_object=None):
        """Construct an object of type ProfileBisection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProfileBisection)
        IProfile.__init__(self, source_object)
        IRuntimeTypeInfoProvider.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IProfile._private_init(self, intf)
        IRuntimeTypeInfoProvider._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ProfileBisection, [ProfileBisection, IProfile, IRuntimeTypeInfoProvider])

agcls.AgClassCatalog.add_catalog_entry((4978358905423378133, 5715780492563669683), ProfileBisection)
agcls.AgTypeNameMap["ProfileBisection"] = ProfileBisection

class BisectionControl(SupportsDeleteCallback):
    """Properties for control parameters of a Bisection Search profile."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_initial_value_method_offset = 5
    _get_current_value_method_offset = 6
    _set_current_value_method_offset = 7
    _get_bound_search_step_method_offset = 8
    _set_bound_search_step_method_offset = 9
    _get_use_custom_display_unit_method_offset = 10
    _set_use_custom_display_unit_method_offset = 11
    _get_custom_display_unit_method_offset = 12
    _set_custom_display_unit_method_offset = 13
    _metadata = {
        "iid_data" : (5506505844080734602, 5687964756702748064),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BisectionControl)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(BisectionControl._metadata, BisectionControl._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_parent_name_metadata)

    _get_initial_value_metadata = { "offset" : _get_initial_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def initial_value(self) -> typing.Any:
        """Get the nominal value of the element selected as a parameter. Dimension depends on context."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_initial_value_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get or set the value of the independent variable after the last targeter run."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_current_value_metadata)

    _set_current_value_metadata = { "offset" : _set_current_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @current_value.setter
    def current_value(self, value:typing.Any) -> None:
        return self._intf.set_property(BisectionControl._metadata, BisectionControl._set_current_value_metadata, value)

    _get_bound_search_step_metadata = { "offset" : _get_bound_search_step_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bound_search_step(self) -> typing.Any:
        """Dimension depends on context."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_bound_search_step_metadata)

    _set_bound_search_step_metadata = { "offset" : _set_bound_search_step_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bound_search_step.setter
    def bound_search_step(self, value:typing.Any) -> None:
        return self._intf.set_property(BisectionControl._metadata, BisectionControl._set_bound_search_step_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(BisectionControl._metadata, BisectionControl._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(BisectionControl._metadata, BisectionControl._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(BisectionControl._metadata, BisectionControl._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[initial_value] = "initial_value"
    _property_names[current_value] = "current_value"
    _property_names[bound_search_step] = "bound_search_step"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type BisectionControl."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BisectionControl)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BisectionControl, [BisectionControl, ])

agcls.AgClassCatalog.add_catalog_entry((5730147831056659199, 16297410616900240567), BisectionControl)
agcls.AgTypeNameMap["BisectionControl"] = BisectionControl

class BisectionControlCollection(SupportsDeleteCallback):
    """Properties for the list of Bisection control parameters."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_control_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5067962422209494432, 14690707282194004360),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BisectionControlCollection)
    def __iter__(self):
        """Create an iterator for the BisectionControlCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "BisectionControl":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "BisectionControl":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(BisectionControlCollection._metadata, BisectionControlCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(BisectionControlCollection._metadata, BisectionControlCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(BisectionControlCollection._metadata, BisectionControlCollection._get_count_metadata)

    _get_control_by_paths_metadata = { "offset" : _get_control_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_control_by_paths(self, object_path:str, control_path:str) -> "BisectionControl":
        """Return the control specified by the object/control path."""
        return self._intf.invoke(BisectionControlCollection._metadata, BisectionControlCollection._get_control_by_paths_metadata, object_path, control_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type BisectionControlCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BisectionControlCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BisectionControlCollection, [BisectionControlCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5413946160255400988, 3723160509644083091), BisectionControlCollection)
agcls.AgTypeNameMap["BisectionControlCollection"] = BisectionControlCollection

class BisectionResult(SupportsDeleteCallback):
    """Properties for result parameters of a Bisection profile."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enable_method_offset = 1
    _set_enable_method_offset = 2
    _get_name_method_offset = 3
    _get_parent_name_method_offset = 4
    _get_current_value_method_offset = 5
    _get_desired_value_method_offset = 6
    _set_desired_value_method_offset = 7
    _get_tolerance_method_offset = 8
    _set_tolerance_method_offset = 9
    _get_use_custom_display_unit_method_offset = 10
    _set_use_custom_display_unit_method_offset = 11
    _get_custom_display_unit_method_offset = 12
    _set_custom_display_unit_method_offset = 13
    _metadata = {
        "iid_data" : (5002983920746056467, 14435764932344965529),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BisectionResult)

    _get_enable_metadata = { "offset" : _get_enable_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable(self) -> bool:
        """If true, the variable is being used."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_enable_metadata)

    _set_enable_metadata = { "offset" : _set_enable_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable.setter
    def enable(self, value:bool) -> None:
        return self._intf.set_property(BisectionResult._metadata, BisectionResult._set_enable_metadata, value)

    _get_name_metadata = { "offset" : _get_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def name(self) -> str:
        """Get the name of the parameter."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_name_metadata)

    _get_parent_name_metadata = { "offset" : _get_parent_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def parent_name(self) -> str:
        """Get the name of the segment to which the parameter belongs."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_parent_name_metadata)

    _get_current_value_metadata = { "offset" : _get_current_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def current_value(self) -> typing.Any:
        """Get the value of the independent variable after the last targeter run."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_current_value_metadata)

    _get_desired_value_metadata = { "offset" : _get_desired_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def desired_value(self) -> typing.Any:
        """Get or set the value that you want to achieve."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_desired_value_metadata)

    _set_desired_value_metadata = { "offset" : _set_desired_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @desired_value.setter
    def desired_value(self, value:typing.Any) -> None:
        return self._intf.set_property(BisectionResult._metadata, BisectionResult._set_desired_value_metadata, value)

    _get_tolerance_metadata = { "offset" : _get_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tolerance(self) -> typing.Any:
        """Get or set the profile will stop when it achieves a value within this range of the Desired Value."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_tolerance_metadata)

    _set_tolerance_metadata = { "offset" : _set_tolerance_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tolerance.setter
    def tolerance(self, value:typing.Any) -> None:
        return self._intf.set_property(BisectionResult._metadata, BisectionResult._set_tolerance_metadata, value)

    _get_use_custom_display_unit_metadata = { "offset" : _get_use_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_custom_display_unit(self) -> bool:
        """If true, allows display of values in another unit."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_use_custom_display_unit_metadata)

    _set_use_custom_display_unit_metadata = { "offset" : _set_use_custom_display_unit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_custom_display_unit.setter
    def use_custom_display_unit(self, value:bool) -> None:
        return self._intf.set_property(BisectionResult._metadata, BisectionResult._set_use_custom_display_unit_metadata, value)

    _get_custom_display_unit_metadata = { "offset" : _get_custom_display_unit_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def custom_display_unit(self) -> str:
        """Get or set the unit in which the value will be displayed in the GUI."""
        return self._intf.get_property(BisectionResult._metadata, BisectionResult._get_custom_display_unit_metadata)

    _set_custom_display_unit_metadata = { "offset" : _set_custom_display_unit_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @custom_display_unit.setter
    def custom_display_unit(self, value:str) -> None:
        return self._intf.set_property(BisectionResult._metadata, BisectionResult._set_custom_display_unit_metadata, value)

    _property_names[enable] = "enable"
    _property_names[name] = "name"
    _property_names[parent_name] = "parent_name"
    _property_names[current_value] = "current_value"
    _property_names[desired_value] = "desired_value"
    _property_names[tolerance] = "tolerance"
    _property_names[use_custom_display_unit] = "use_custom_display_unit"
    _property_names[custom_display_unit] = "custom_display_unit"

    def __init__(self, source_object=None):
        """Construct an object of type BisectionResult."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BisectionResult)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BisectionResult, [BisectionResult, ])

agcls.AgClassCatalog.add_catalog_entry((4679191932121975856, 3661654645336243355), BisectionResult)
agcls.AgTypeNameMap["BisectionResult"] = BisectionResult

class BisectionResultCollection(SupportsDeleteCallback):
    """Bisection result collection."""

    _num_methods = 4
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _item_method_offset = 1
    _get__new_enum_method_offset = 2
    _get_count_method_offset = 3
    _get_result_by_paths_method_offset = 4
    _metadata = {
        "iid_data" : (5274158208537002615, 13074544314501011364),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BisectionResultCollection)
    def __iter__(self):
        """Create an iterator for the BisectionResultCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "BisectionResult":
        """Return the next element in the collection."""
        if self._enumerator is None:
            raise StopIteration
        nextval = self._enumerator.next()
        if nextval is None:
            raise StopIteration
        return nextval

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "BisectionResult":
        """Allow you to iterate through the collection."""
        return self._intf.invoke(BisectionResultCollection._metadata, BisectionResultCollection._item_metadata, index, OutArg())

    _get__new_enum_metadata = { "offset" : _get__new_enum_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.IEnumVariantArg,) }
    @property
    def _new_enum(self) -> EnumeratorProxy:
        """Allow you to enumerate through the collection."""
        return self._intf.get_property(BisectionResultCollection._metadata, BisectionResultCollection._get__new_enum_metadata)

    _get_count_metadata = { "offset" : _get_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def count(self) -> int:
        """Return the size of the collection."""
        return self._intf.get_property(BisectionResultCollection._metadata, BisectionResultCollection._get_count_metadata)

    _get_result_by_paths_metadata = { "offset" : _get_result_by_paths_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_result_by_paths(self, object_path:str, result_path:str) -> "BisectionResult":
        """Return the result specified by the object/result names."""
        return self._intf.invoke(BisectionResultCollection._metadata, BisectionResultCollection._get_result_by_paths_metadata, object_path, result_path, OutArg())

    __getitem__ = item


    _property_names[_new_enum] = "_new_enum"
    _property_names[count] = "count"

    def __init__(self, source_object=None):
        """Construct an object of type BisectionResultCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BisectionResultCollection)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BisectionResultCollection, [BisectionResultCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5219088716918017814, 2293503427773161615), BisectionResultCollection)
agcls.AgTypeNameMap["BisectionResultCollection"] = BisectionResultCollection